1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package inspector
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/inspector/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAddAttributesToFindings struct {
14}
15
16func (*validateOpAddAttributesToFindings) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAddAttributesToFindings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
21	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
22) {
23	input, ok := in.Parameters.(*AddAttributesToFindingsInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAddAttributesToFindingsInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateAssessmentTarget struct {
34}
35
36func (*validateOpCreateAssessmentTarget) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateAssessmentTarget) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
41	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
42) {
43	input, ok := in.Parameters.(*CreateAssessmentTargetInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateAssessmentTargetInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateAssessmentTemplate struct {
54}
55
56func (*validateOpCreateAssessmentTemplate) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateAssessmentTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
61	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
62) {
63	input, ok := in.Parameters.(*CreateAssessmentTemplateInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateAssessmentTemplateInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateExclusionsPreview struct {
74}
75
76func (*validateOpCreateExclusionsPreview) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateExclusionsPreview) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
81	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
82) {
83	input, ok := in.Parameters.(*CreateExclusionsPreviewInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateExclusionsPreviewInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateResourceGroup struct {
94}
95
96func (*validateOpCreateResourceGroup) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateResourceGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
102) {
103	input, ok := in.Parameters.(*CreateResourceGroupInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateResourceGroupInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDeleteAssessmentRun struct {
114}
115
116func (*validateOpDeleteAssessmentRun) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDeleteAssessmentRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
122) {
123	input, ok := in.Parameters.(*DeleteAssessmentRunInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDeleteAssessmentRunInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDeleteAssessmentTarget struct {
134}
135
136func (*validateOpDeleteAssessmentTarget) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDeleteAssessmentTarget) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
142) {
143	input, ok := in.Parameters.(*DeleteAssessmentTargetInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDeleteAssessmentTargetInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDeleteAssessmentTemplate struct {
154}
155
156func (*validateOpDeleteAssessmentTemplate) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDeleteAssessmentTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
161	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
162) {
163	input, ok := in.Parameters.(*DeleteAssessmentTemplateInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDeleteAssessmentTemplateInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDescribeAssessmentRuns struct {
174}
175
176func (*validateOpDescribeAssessmentRuns) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDescribeAssessmentRuns) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
181	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
182) {
183	input, ok := in.Parameters.(*DescribeAssessmentRunsInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDescribeAssessmentRunsInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDescribeAssessmentTargets struct {
194}
195
196func (*validateOpDescribeAssessmentTargets) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDescribeAssessmentTargets) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
201	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
202) {
203	input, ok := in.Parameters.(*DescribeAssessmentTargetsInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDescribeAssessmentTargetsInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpDescribeAssessmentTemplates struct {
214}
215
216func (*validateOpDescribeAssessmentTemplates) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpDescribeAssessmentTemplates) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
221	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
222) {
223	input, ok := in.Parameters.(*DescribeAssessmentTemplatesInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpDescribeAssessmentTemplatesInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDescribeExclusions struct {
234}
235
236func (*validateOpDescribeExclusions) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDescribeExclusions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
241	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
242) {
243	input, ok := in.Parameters.(*DescribeExclusionsInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDescribeExclusionsInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDescribeFindings struct {
254}
255
256func (*validateOpDescribeFindings) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDescribeFindings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
261	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
262) {
263	input, ok := in.Parameters.(*DescribeFindingsInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDescribeFindingsInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDescribeResourceGroups struct {
274}
275
276func (*validateOpDescribeResourceGroups) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDescribeResourceGroups) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
281	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
282) {
283	input, ok := in.Parameters.(*DescribeResourceGroupsInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDescribeResourceGroupsInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDescribeRulesPackages struct {
294}
295
296func (*validateOpDescribeRulesPackages) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDescribeRulesPackages) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
301	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
302) {
303	input, ok := in.Parameters.(*DescribeRulesPackagesInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDescribeRulesPackagesInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpGetAssessmentReport struct {
314}
315
316func (*validateOpGetAssessmentReport) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpGetAssessmentReport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
321	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
322) {
323	input, ok := in.Parameters.(*GetAssessmentReportInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpGetAssessmentReportInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpGetExclusionsPreview struct {
334}
335
336func (*validateOpGetExclusionsPreview) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpGetExclusionsPreview) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
341	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
342) {
343	input, ok := in.Parameters.(*GetExclusionsPreviewInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpGetExclusionsPreviewInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpGetTelemetryMetadata struct {
354}
355
356func (*validateOpGetTelemetryMetadata) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpGetTelemetryMetadata) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
361	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
362) {
363	input, ok := in.Parameters.(*GetTelemetryMetadataInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpGetTelemetryMetadataInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpListAssessmentRunAgents struct {
374}
375
376func (*validateOpListAssessmentRunAgents) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpListAssessmentRunAgents) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
381	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
382) {
383	input, ok := in.Parameters.(*ListAssessmentRunAgentsInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpListAssessmentRunAgentsInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpListExclusions struct {
394}
395
396func (*validateOpListExclusions) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpListExclusions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
401	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
402) {
403	input, ok := in.Parameters.(*ListExclusionsInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpListExclusionsInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpListFindings struct {
414}
415
416func (*validateOpListFindings) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpListFindings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
421	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
422) {
423	input, ok := in.Parameters.(*ListFindingsInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpListFindingsInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpListTagsForResource struct {
434}
435
436func (*validateOpListTagsForResource) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
441	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
442) {
443	input, ok := in.Parameters.(*ListTagsForResourceInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpListTagsForResourceInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpPreviewAgents struct {
454}
455
456func (*validateOpPreviewAgents) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpPreviewAgents) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
461	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
462) {
463	input, ok := in.Parameters.(*PreviewAgentsInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpPreviewAgentsInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpRegisterCrossAccountAccessRole struct {
474}
475
476func (*validateOpRegisterCrossAccountAccessRole) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpRegisterCrossAccountAccessRole) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
481	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
482) {
483	input, ok := in.Parameters.(*RegisterCrossAccountAccessRoleInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpRegisterCrossAccountAccessRoleInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpRemoveAttributesFromFindings struct {
494}
495
496func (*validateOpRemoveAttributesFromFindings) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpRemoveAttributesFromFindings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
501	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
502) {
503	input, ok := in.Parameters.(*RemoveAttributesFromFindingsInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpRemoveAttributesFromFindingsInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpSetTagsForResource struct {
514}
515
516func (*validateOpSetTagsForResource) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpSetTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
521	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
522) {
523	input, ok := in.Parameters.(*SetTagsForResourceInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpSetTagsForResourceInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpStartAssessmentRun struct {
534}
535
536func (*validateOpStartAssessmentRun) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpStartAssessmentRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
541	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
542) {
543	input, ok := in.Parameters.(*StartAssessmentRunInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpStartAssessmentRunInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpStopAssessmentRun struct {
554}
555
556func (*validateOpStopAssessmentRun) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpStopAssessmentRun) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
561	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
562) {
563	input, ok := in.Parameters.(*StopAssessmentRunInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpStopAssessmentRunInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpSubscribeToEvent struct {
574}
575
576func (*validateOpSubscribeToEvent) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpSubscribeToEvent) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
581	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
582) {
583	input, ok := in.Parameters.(*SubscribeToEventInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpSubscribeToEventInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpUnsubscribeFromEvent struct {
594}
595
596func (*validateOpUnsubscribeFromEvent) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpUnsubscribeFromEvent) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
601	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
602) {
603	input, ok := in.Parameters.(*UnsubscribeFromEventInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpUnsubscribeFromEventInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpUpdateAssessmentTarget struct {
614}
615
616func (*validateOpUpdateAssessmentTarget) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpUpdateAssessmentTarget) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
621	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
622) {
623	input, ok := in.Parameters.(*UpdateAssessmentTargetInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpUpdateAssessmentTargetInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633func addOpAddAttributesToFindingsValidationMiddleware(stack *middleware.Stack) error {
634	return stack.Initialize.Add(&validateOpAddAttributesToFindings{}, middleware.After)
635}
636
637func addOpCreateAssessmentTargetValidationMiddleware(stack *middleware.Stack) error {
638	return stack.Initialize.Add(&validateOpCreateAssessmentTarget{}, middleware.After)
639}
640
641func addOpCreateAssessmentTemplateValidationMiddleware(stack *middleware.Stack) error {
642	return stack.Initialize.Add(&validateOpCreateAssessmentTemplate{}, middleware.After)
643}
644
645func addOpCreateExclusionsPreviewValidationMiddleware(stack *middleware.Stack) error {
646	return stack.Initialize.Add(&validateOpCreateExclusionsPreview{}, middleware.After)
647}
648
649func addOpCreateResourceGroupValidationMiddleware(stack *middleware.Stack) error {
650	return stack.Initialize.Add(&validateOpCreateResourceGroup{}, middleware.After)
651}
652
653func addOpDeleteAssessmentRunValidationMiddleware(stack *middleware.Stack) error {
654	return stack.Initialize.Add(&validateOpDeleteAssessmentRun{}, middleware.After)
655}
656
657func addOpDeleteAssessmentTargetValidationMiddleware(stack *middleware.Stack) error {
658	return stack.Initialize.Add(&validateOpDeleteAssessmentTarget{}, middleware.After)
659}
660
661func addOpDeleteAssessmentTemplateValidationMiddleware(stack *middleware.Stack) error {
662	return stack.Initialize.Add(&validateOpDeleteAssessmentTemplate{}, middleware.After)
663}
664
665func addOpDescribeAssessmentRunsValidationMiddleware(stack *middleware.Stack) error {
666	return stack.Initialize.Add(&validateOpDescribeAssessmentRuns{}, middleware.After)
667}
668
669func addOpDescribeAssessmentTargetsValidationMiddleware(stack *middleware.Stack) error {
670	return stack.Initialize.Add(&validateOpDescribeAssessmentTargets{}, middleware.After)
671}
672
673func addOpDescribeAssessmentTemplatesValidationMiddleware(stack *middleware.Stack) error {
674	return stack.Initialize.Add(&validateOpDescribeAssessmentTemplates{}, middleware.After)
675}
676
677func addOpDescribeExclusionsValidationMiddleware(stack *middleware.Stack) error {
678	return stack.Initialize.Add(&validateOpDescribeExclusions{}, middleware.After)
679}
680
681func addOpDescribeFindingsValidationMiddleware(stack *middleware.Stack) error {
682	return stack.Initialize.Add(&validateOpDescribeFindings{}, middleware.After)
683}
684
685func addOpDescribeResourceGroupsValidationMiddleware(stack *middleware.Stack) error {
686	return stack.Initialize.Add(&validateOpDescribeResourceGroups{}, middleware.After)
687}
688
689func addOpDescribeRulesPackagesValidationMiddleware(stack *middleware.Stack) error {
690	return stack.Initialize.Add(&validateOpDescribeRulesPackages{}, middleware.After)
691}
692
693func addOpGetAssessmentReportValidationMiddleware(stack *middleware.Stack) error {
694	return stack.Initialize.Add(&validateOpGetAssessmentReport{}, middleware.After)
695}
696
697func addOpGetExclusionsPreviewValidationMiddleware(stack *middleware.Stack) error {
698	return stack.Initialize.Add(&validateOpGetExclusionsPreview{}, middleware.After)
699}
700
701func addOpGetTelemetryMetadataValidationMiddleware(stack *middleware.Stack) error {
702	return stack.Initialize.Add(&validateOpGetTelemetryMetadata{}, middleware.After)
703}
704
705func addOpListAssessmentRunAgentsValidationMiddleware(stack *middleware.Stack) error {
706	return stack.Initialize.Add(&validateOpListAssessmentRunAgents{}, middleware.After)
707}
708
709func addOpListExclusionsValidationMiddleware(stack *middleware.Stack) error {
710	return stack.Initialize.Add(&validateOpListExclusions{}, middleware.After)
711}
712
713func addOpListFindingsValidationMiddleware(stack *middleware.Stack) error {
714	return stack.Initialize.Add(&validateOpListFindings{}, middleware.After)
715}
716
717func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
718	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
719}
720
721func addOpPreviewAgentsValidationMiddleware(stack *middleware.Stack) error {
722	return stack.Initialize.Add(&validateOpPreviewAgents{}, middleware.After)
723}
724
725func addOpRegisterCrossAccountAccessRoleValidationMiddleware(stack *middleware.Stack) error {
726	return stack.Initialize.Add(&validateOpRegisterCrossAccountAccessRole{}, middleware.After)
727}
728
729func addOpRemoveAttributesFromFindingsValidationMiddleware(stack *middleware.Stack) error {
730	return stack.Initialize.Add(&validateOpRemoveAttributesFromFindings{}, middleware.After)
731}
732
733func addOpSetTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
734	return stack.Initialize.Add(&validateOpSetTagsForResource{}, middleware.After)
735}
736
737func addOpStartAssessmentRunValidationMiddleware(stack *middleware.Stack) error {
738	return stack.Initialize.Add(&validateOpStartAssessmentRun{}, middleware.After)
739}
740
741func addOpStopAssessmentRunValidationMiddleware(stack *middleware.Stack) error {
742	return stack.Initialize.Add(&validateOpStopAssessmentRun{}, middleware.After)
743}
744
745func addOpSubscribeToEventValidationMiddleware(stack *middleware.Stack) error {
746	return stack.Initialize.Add(&validateOpSubscribeToEvent{}, middleware.After)
747}
748
749func addOpUnsubscribeFromEventValidationMiddleware(stack *middleware.Stack) error {
750	return stack.Initialize.Add(&validateOpUnsubscribeFromEvent{}, middleware.After)
751}
752
753func addOpUpdateAssessmentTargetValidationMiddleware(stack *middleware.Stack) error {
754	return stack.Initialize.Add(&validateOpUpdateAssessmentTarget{}, middleware.After)
755}
756
757func validateAgentFilter(v *types.AgentFilter) error {
758	if v == nil {
759		return nil
760	}
761	invalidParams := smithy.InvalidParamsError{Context: "AgentFilter"}
762	if v.AgentHealths == nil {
763		invalidParams.Add(smithy.NewErrParamRequired("AgentHealths"))
764	}
765	if v.AgentHealthCodes == nil {
766		invalidParams.Add(smithy.NewErrParamRequired("AgentHealthCodes"))
767	}
768	if invalidParams.Len() > 0 {
769		return invalidParams
770	} else {
771		return nil
772	}
773}
774
775func validateAttribute(v *types.Attribute) error {
776	if v == nil {
777		return nil
778	}
779	invalidParams := smithy.InvalidParamsError{Context: "Attribute"}
780	if v.Key == nil {
781		invalidParams.Add(smithy.NewErrParamRequired("Key"))
782	}
783	if invalidParams.Len() > 0 {
784		return invalidParams
785	} else {
786		return nil
787	}
788}
789
790func validateAttributeList(v []types.Attribute) error {
791	if v == nil {
792		return nil
793	}
794	invalidParams := smithy.InvalidParamsError{Context: "AttributeList"}
795	for i := range v {
796		if err := validateAttribute(&v[i]); err != nil {
797			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
798		}
799	}
800	if invalidParams.Len() > 0 {
801		return invalidParams
802	} else {
803		return nil
804	}
805}
806
807func validateFindingFilter(v *types.FindingFilter) error {
808	if v == nil {
809		return nil
810	}
811	invalidParams := smithy.InvalidParamsError{Context: "FindingFilter"}
812	if v.Attributes != nil {
813		if err := validateAttributeList(v.Attributes); err != nil {
814			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
815		}
816	}
817	if v.UserAttributes != nil {
818		if err := validateAttributeList(v.UserAttributes); err != nil {
819			invalidParams.AddNested("UserAttributes", err.(smithy.InvalidParamsError))
820		}
821	}
822	if invalidParams.Len() > 0 {
823		return invalidParams
824	} else {
825		return nil
826	}
827}
828
829func validateResourceGroupTag(v *types.ResourceGroupTag) error {
830	if v == nil {
831		return nil
832	}
833	invalidParams := smithy.InvalidParamsError{Context: "ResourceGroupTag"}
834	if v.Key == nil {
835		invalidParams.Add(smithy.NewErrParamRequired("Key"))
836	}
837	if invalidParams.Len() > 0 {
838		return invalidParams
839	} else {
840		return nil
841	}
842}
843
844func validateResourceGroupTags(v []types.ResourceGroupTag) error {
845	if v == nil {
846		return nil
847	}
848	invalidParams := smithy.InvalidParamsError{Context: "ResourceGroupTags"}
849	for i := range v {
850		if err := validateResourceGroupTag(&v[i]); err != nil {
851			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
852		}
853	}
854	if invalidParams.Len() > 0 {
855		return invalidParams
856	} else {
857		return nil
858	}
859}
860
861func validateTag(v *types.Tag) error {
862	if v == nil {
863		return nil
864	}
865	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
866	if v.Key == nil {
867		invalidParams.Add(smithy.NewErrParamRequired("Key"))
868	}
869	if invalidParams.Len() > 0 {
870		return invalidParams
871	} else {
872		return nil
873	}
874}
875
876func validateTagList(v []types.Tag) error {
877	if v == nil {
878		return nil
879	}
880	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
881	for i := range v {
882		if err := validateTag(&v[i]); err != nil {
883			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
884		}
885	}
886	if invalidParams.Len() > 0 {
887		return invalidParams
888	} else {
889		return nil
890	}
891}
892
893func validateUserAttributeList(v []types.Attribute) error {
894	if v == nil {
895		return nil
896	}
897	invalidParams := smithy.InvalidParamsError{Context: "UserAttributeList"}
898	for i := range v {
899		if err := validateAttribute(&v[i]); err != nil {
900			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
901		}
902	}
903	if invalidParams.Len() > 0 {
904		return invalidParams
905	} else {
906		return nil
907	}
908}
909
910func validateOpAddAttributesToFindingsInput(v *AddAttributesToFindingsInput) error {
911	if v == nil {
912		return nil
913	}
914	invalidParams := smithy.InvalidParamsError{Context: "AddAttributesToFindingsInput"}
915	if v.FindingArns == nil {
916		invalidParams.Add(smithy.NewErrParamRequired("FindingArns"))
917	}
918	if v.Attributes == nil {
919		invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
920	} else if v.Attributes != nil {
921		if err := validateUserAttributeList(v.Attributes); err != nil {
922			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
923		}
924	}
925	if invalidParams.Len() > 0 {
926		return invalidParams
927	} else {
928		return nil
929	}
930}
931
932func validateOpCreateAssessmentTargetInput(v *CreateAssessmentTargetInput) error {
933	if v == nil {
934		return nil
935	}
936	invalidParams := smithy.InvalidParamsError{Context: "CreateAssessmentTargetInput"}
937	if v.AssessmentTargetName == nil {
938		invalidParams.Add(smithy.NewErrParamRequired("AssessmentTargetName"))
939	}
940	if invalidParams.Len() > 0 {
941		return invalidParams
942	} else {
943		return nil
944	}
945}
946
947func validateOpCreateAssessmentTemplateInput(v *CreateAssessmentTemplateInput) error {
948	if v == nil {
949		return nil
950	}
951	invalidParams := smithy.InvalidParamsError{Context: "CreateAssessmentTemplateInput"}
952	if v.AssessmentTargetArn == nil {
953		invalidParams.Add(smithy.NewErrParamRequired("AssessmentTargetArn"))
954	}
955	if v.AssessmentTemplateName == nil {
956		invalidParams.Add(smithy.NewErrParamRequired("AssessmentTemplateName"))
957	}
958	if v.RulesPackageArns == nil {
959		invalidParams.Add(smithy.NewErrParamRequired("RulesPackageArns"))
960	}
961	if v.UserAttributesForFindings != nil {
962		if err := validateUserAttributeList(v.UserAttributesForFindings); err != nil {
963			invalidParams.AddNested("UserAttributesForFindings", err.(smithy.InvalidParamsError))
964		}
965	}
966	if invalidParams.Len() > 0 {
967		return invalidParams
968	} else {
969		return nil
970	}
971}
972
973func validateOpCreateExclusionsPreviewInput(v *CreateExclusionsPreviewInput) error {
974	if v == nil {
975		return nil
976	}
977	invalidParams := smithy.InvalidParamsError{Context: "CreateExclusionsPreviewInput"}
978	if v.AssessmentTemplateArn == nil {
979		invalidParams.Add(smithy.NewErrParamRequired("AssessmentTemplateArn"))
980	}
981	if invalidParams.Len() > 0 {
982		return invalidParams
983	} else {
984		return nil
985	}
986}
987
988func validateOpCreateResourceGroupInput(v *CreateResourceGroupInput) error {
989	if v == nil {
990		return nil
991	}
992	invalidParams := smithy.InvalidParamsError{Context: "CreateResourceGroupInput"}
993	if v.ResourceGroupTags == nil {
994		invalidParams.Add(smithy.NewErrParamRequired("ResourceGroupTags"))
995	} else if v.ResourceGroupTags != nil {
996		if err := validateResourceGroupTags(v.ResourceGroupTags); err != nil {
997			invalidParams.AddNested("ResourceGroupTags", err.(smithy.InvalidParamsError))
998		}
999	}
1000	if invalidParams.Len() > 0 {
1001		return invalidParams
1002	} else {
1003		return nil
1004	}
1005}
1006
1007func validateOpDeleteAssessmentRunInput(v *DeleteAssessmentRunInput) error {
1008	if v == nil {
1009		return nil
1010	}
1011	invalidParams := smithy.InvalidParamsError{Context: "DeleteAssessmentRunInput"}
1012	if v.AssessmentRunArn == nil {
1013		invalidParams.Add(smithy.NewErrParamRequired("AssessmentRunArn"))
1014	}
1015	if invalidParams.Len() > 0 {
1016		return invalidParams
1017	} else {
1018		return nil
1019	}
1020}
1021
1022func validateOpDeleteAssessmentTargetInput(v *DeleteAssessmentTargetInput) error {
1023	if v == nil {
1024		return nil
1025	}
1026	invalidParams := smithy.InvalidParamsError{Context: "DeleteAssessmentTargetInput"}
1027	if v.AssessmentTargetArn == nil {
1028		invalidParams.Add(smithy.NewErrParamRequired("AssessmentTargetArn"))
1029	}
1030	if invalidParams.Len() > 0 {
1031		return invalidParams
1032	} else {
1033		return nil
1034	}
1035}
1036
1037func validateOpDeleteAssessmentTemplateInput(v *DeleteAssessmentTemplateInput) error {
1038	if v == nil {
1039		return nil
1040	}
1041	invalidParams := smithy.InvalidParamsError{Context: "DeleteAssessmentTemplateInput"}
1042	if v.AssessmentTemplateArn == nil {
1043		invalidParams.Add(smithy.NewErrParamRequired("AssessmentTemplateArn"))
1044	}
1045	if invalidParams.Len() > 0 {
1046		return invalidParams
1047	} else {
1048		return nil
1049	}
1050}
1051
1052func validateOpDescribeAssessmentRunsInput(v *DescribeAssessmentRunsInput) error {
1053	if v == nil {
1054		return nil
1055	}
1056	invalidParams := smithy.InvalidParamsError{Context: "DescribeAssessmentRunsInput"}
1057	if v.AssessmentRunArns == nil {
1058		invalidParams.Add(smithy.NewErrParamRequired("AssessmentRunArns"))
1059	}
1060	if invalidParams.Len() > 0 {
1061		return invalidParams
1062	} else {
1063		return nil
1064	}
1065}
1066
1067func validateOpDescribeAssessmentTargetsInput(v *DescribeAssessmentTargetsInput) error {
1068	if v == nil {
1069		return nil
1070	}
1071	invalidParams := smithy.InvalidParamsError{Context: "DescribeAssessmentTargetsInput"}
1072	if v.AssessmentTargetArns == nil {
1073		invalidParams.Add(smithy.NewErrParamRequired("AssessmentTargetArns"))
1074	}
1075	if invalidParams.Len() > 0 {
1076		return invalidParams
1077	} else {
1078		return nil
1079	}
1080}
1081
1082func validateOpDescribeAssessmentTemplatesInput(v *DescribeAssessmentTemplatesInput) error {
1083	if v == nil {
1084		return nil
1085	}
1086	invalidParams := smithy.InvalidParamsError{Context: "DescribeAssessmentTemplatesInput"}
1087	if v.AssessmentTemplateArns == nil {
1088		invalidParams.Add(smithy.NewErrParamRequired("AssessmentTemplateArns"))
1089	}
1090	if invalidParams.Len() > 0 {
1091		return invalidParams
1092	} else {
1093		return nil
1094	}
1095}
1096
1097func validateOpDescribeExclusionsInput(v *DescribeExclusionsInput) error {
1098	if v == nil {
1099		return nil
1100	}
1101	invalidParams := smithy.InvalidParamsError{Context: "DescribeExclusionsInput"}
1102	if v.ExclusionArns == nil {
1103		invalidParams.Add(smithy.NewErrParamRequired("ExclusionArns"))
1104	}
1105	if invalidParams.Len() > 0 {
1106		return invalidParams
1107	} else {
1108		return nil
1109	}
1110}
1111
1112func validateOpDescribeFindingsInput(v *DescribeFindingsInput) error {
1113	if v == nil {
1114		return nil
1115	}
1116	invalidParams := smithy.InvalidParamsError{Context: "DescribeFindingsInput"}
1117	if v.FindingArns == nil {
1118		invalidParams.Add(smithy.NewErrParamRequired("FindingArns"))
1119	}
1120	if invalidParams.Len() > 0 {
1121		return invalidParams
1122	} else {
1123		return nil
1124	}
1125}
1126
1127func validateOpDescribeResourceGroupsInput(v *DescribeResourceGroupsInput) error {
1128	if v == nil {
1129		return nil
1130	}
1131	invalidParams := smithy.InvalidParamsError{Context: "DescribeResourceGroupsInput"}
1132	if v.ResourceGroupArns == nil {
1133		invalidParams.Add(smithy.NewErrParamRequired("ResourceGroupArns"))
1134	}
1135	if invalidParams.Len() > 0 {
1136		return invalidParams
1137	} else {
1138		return nil
1139	}
1140}
1141
1142func validateOpDescribeRulesPackagesInput(v *DescribeRulesPackagesInput) error {
1143	if v == nil {
1144		return nil
1145	}
1146	invalidParams := smithy.InvalidParamsError{Context: "DescribeRulesPackagesInput"}
1147	if v.RulesPackageArns == nil {
1148		invalidParams.Add(smithy.NewErrParamRequired("RulesPackageArns"))
1149	}
1150	if invalidParams.Len() > 0 {
1151		return invalidParams
1152	} else {
1153		return nil
1154	}
1155}
1156
1157func validateOpGetAssessmentReportInput(v *GetAssessmentReportInput) error {
1158	if v == nil {
1159		return nil
1160	}
1161	invalidParams := smithy.InvalidParamsError{Context: "GetAssessmentReportInput"}
1162	if v.AssessmentRunArn == nil {
1163		invalidParams.Add(smithy.NewErrParamRequired("AssessmentRunArn"))
1164	}
1165	if len(v.ReportFileFormat) == 0 {
1166		invalidParams.Add(smithy.NewErrParamRequired("ReportFileFormat"))
1167	}
1168	if len(v.ReportType) == 0 {
1169		invalidParams.Add(smithy.NewErrParamRequired("ReportType"))
1170	}
1171	if invalidParams.Len() > 0 {
1172		return invalidParams
1173	} else {
1174		return nil
1175	}
1176}
1177
1178func validateOpGetExclusionsPreviewInput(v *GetExclusionsPreviewInput) error {
1179	if v == nil {
1180		return nil
1181	}
1182	invalidParams := smithy.InvalidParamsError{Context: "GetExclusionsPreviewInput"}
1183	if v.AssessmentTemplateArn == nil {
1184		invalidParams.Add(smithy.NewErrParamRequired("AssessmentTemplateArn"))
1185	}
1186	if v.PreviewToken == nil {
1187		invalidParams.Add(smithy.NewErrParamRequired("PreviewToken"))
1188	}
1189	if invalidParams.Len() > 0 {
1190		return invalidParams
1191	} else {
1192		return nil
1193	}
1194}
1195
1196func validateOpGetTelemetryMetadataInput(v *GetTelemetryMetadataInput) error {
1197	if v == nil {
1198		return nil
1199	}
1200	invalidParams := smithy.InvalidParamsError{Context: "GetTelemetryMetadataInput"}
1201	if v.AssessmentRunArn == nil {
1202		invalidParams.Add(smithy.NewErrParamRequired("AssessmentRunArn"))
1203	}
1204	if invalidParams.Len() > 0 {
1205		return invalidParams
1206	} else {
1207		return nil
1208	}
1209}
1210
1211func validateOpListAssessmentRunAgentsInput(v *ListAssessmentRunAgentsInput) error {
1212	if v == nil {
1213		return nil
1214	}
1215	invalidParams := smithy.InvalidParamsError{Context: "ListAssessmentRunAgentsInput"}
1216	if v.AssessmentRunArn == nil {
1217		invalidParams.Add(smithy.NewErrParamRequired("AssessmentRunArn"))
1218	}
1219	if v.Filter != nil {
1220		if err := validateAgentFilter(v.Filter); err != nil {
1221			invalidParams.AddNested("Filter", err.(smithy.InvalidParamsError))
1222		}
1223	}
1224	if invalidParams.Len() > 0 {
1225		return invalidParams
1226	} else {
1227		return nil
1228	}
1229}
1230
1231func validateOpListExclusionsInput(v *ListExclusionsInput) error {
1232	if v == nil {
1233		return nil
1234	}
1235	invalidParams := smithy.InvalidParamsError{Context: "ListExclusionsInput"}
1236	if v.AssessmentRunArn == nil {
1237		invalidParams.Add(smithy.NewErrParamRequired("AssessmentRunArn"))
1238	}
1239	if invalidParams.Len() > 0 {
1240		return invalidParams
1241	} else {
1242		return nil
1243	}
1244}
1245
1246func validateOpListFindingsInput(v *ListFindingsInput) error {
1247	if v == nil {
1248		return nil
1249	}
1250	invalidParams := smithy.InvalidParamsError{Context: "ListFindingsInput"}
1251	if v.Filter != nil {
1252		if err := validateFindingFilter(v.Filter); err != nil {
1253			invalidParams.AddNested("Filter", err.(smithy.InvalidParamsError))
1254		}
1255	}
1256	if invalidParams.Len() > 0 {
1257		return invalidParams
1258	} else {
1259		return nil
1260	}
1261}
1262
1263func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1264	if v == nil {
1265		return nil
1266	}
1267	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1268	if v.ResourceArn == nil {
1269		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1270	}
1271	if invalidParams.Len() > 0 {
1272		return invalidParams
1273	} else {
1274		return nil
1275	}
1276}
1277
1278func validateOpPreviewAgentsInput(v *PreviewAgentsInput) error {
1279	if v == nil {
1280		return nil
1281	}
1282	invalidParams := smithy.InvalidParamsError{Context: "PreviewAgentsInput"}
1283	if v.PreviewAgentsArn == nil {
1284		invalidParams.Add(smithy.NewErrParamRequired("PreviewAgentsArn"))
1285	}
1286	if invalidParams.Len() > 0 {
1287		return invalidParams
1288	} else {
1289		return nil
1290	}
1291}
1292
1293func validateOpRegisterCrossAccountAccessRoleInput(v *RegisterCrossAccountAccessRoleInput) error {
1294	if v == nil {
1295		return nil
1296	}
1297	invalidParams := smithy.InvalidParamsError{Context: "RegisterCrossAccountAccessRoleInput"}
1298	if v.RoleArn == nil {
1299		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
1300	}
1301	if invalidParams.Len() > 0 {
1302		return invalidParams
1303	} else {
1304		return nil
1305	}
1306}
1307
1308func validateOpRemoveAttributesFromFindingsInput(v *RemoveAttributesFromFindingsInput) error {
1309	if v == nil {
1310		return nil
1311	}
1312	invalidParams := smithy.InvalidParamsError{Context: "RemoveAttributesFromFindingsInput"}
1313	if v.FindingArns == nil {
1314		invalidParams.Add(smithy.NewErrParamRequired("FindingArns"))
1315	}
1316	if v.AttributeKeys == nil {
1317		invalidParams.Add(smithy.NewErrParamRequired("AttributeKeys"))
1318	}
1319	if invalidParams.Len() > 0 {
1320		return invalidParams
1321	} else {
1322		return nil
1323	}
1324}
1325
1326func validateOpSetTagsForResourceInput(v *SetTagsForResourceInput) error {
1327	if v == nil {
1328		return nil
1329	}
1330	invalidParams := smithy.InvalidParamsError{Context: "SetTagsForResourceInput"}
1331	if v.ResourceArn == nil {
1332		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1333	}
1334	if v.Tags != nil {
1335		if err := validateTagList(v.Tags); err != nil {
1336			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1337		}
1338	}
1339	if invalidParams.Len() > 0 {
1340		return invalidParams
1341	} else {
1342		return nil
1343	}
1344}
1345
1346func validateOpStartAssessmentRunInput(v *StartAssessmentRunInput) error {
1347	if v == nil {
1348		return nil
1349	}
1350	invalidParams := smithy.InvalidParamsError{Context: "StartAssessmentRunInput"}
1351	if v.AssessmentTemplateArn == nil {
1352		invalidParams.Add(smithy.NewErrParamRequired("AssessmentTemplateArn"))
1353	}
1354	if invalidParams.Len() > 0 {
1355		return invalidParams
1356	} else {
1357		return nil
1358	}
1359}
1360
1361func validateOpStopAssessmentRunInput(v *StopAssessmentRunInput) error {
1362	if v == nil {
1363		return nil
1364	}
1365	invalidParams := smithy.InvalidParamsError{Context: "StopAssessmentRunInput"}
1366	if v.AssessmentRunArn == nil {
1367		invalidParams.Add(smithy.NewErrParamRequired("AssessmentRunArn"))
1368	}
1369	if invalidParams.Len() > 0 {
1370		return invalidParams
1371	} else {
1372		return nil
1373	}
1374}
1375
1376func validateOpSubscribeToEventInput(v *SubscribeToEventInput) error {
1377	if v == nil {
1378		return nil
1379	}
1380	invalidParams := smithy.InvalidParamsError{Context: "SubscribeToEventInput"}
1381	if v.ResourceArn == nil {
1382		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1383	}
1384	if len(v.Event) == 0 {
1385		invalidParams.Add(smithy.NewErrParamRequired("Event"))
1386	}
1387	if v.TopicArn == nil {
1388		invalidParams.Add(smithy.NewErrParamRequired("TopicArn"))
1389	}
1390	if invalidParams.Len() > 0 {
1391		return invalidParams
1392	} else {
1393		return nil
1394	}
1395}
1396
1397func validateOpUnsubscribeFromEventInput(v *UnsubscribeFromEventInput) error {
1398	if v == nil {
1399		return nil
1400	}
1401	invalidParams := smithy.InvalidParamsError{Context: "UnsubscribeFromEventInput"}
1402	if v.ResourceArn == nil {
1403		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1404	}
1405	if len(v.Event) == 0 {
1406		invalidParams.Add(smithy.NewErrParamRequired("Event"))
1407	}
1408	if v.TopicArn == nil {
1409		invalidParams.Add(smithy.NewErrParamRequired("TopicArn"))
1410	}
1411	if invalidParams.Len() > 0 {
1412		return invalidParams
1413	} else {
1414		return nil
1415	}
1416}
1417
1418func validateOpUpdateAssessmentTargetInput(v *UpdateAssessmentTargetInput) error {
1419	if v == nil {
1420		return nil
1421	}
1422	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssessmentTargetInput"}
1423	if v.AssessmentTargetArn == nil {
1424		invalidParams.Add(smithy.NewErrParamRequired("AssessmentTargetArn"))
1425	}
1426	if v.AssessmentTargetName == nil {
1427		invalidParams.Add(smithy.NewErrParamRequired("AssessmentTargetName"))
1428	}
1429	if invalidParams.Len() > 0 {
1430		return invalidParams
1431	} else {
1432		return nil
1433	}
1434}
1435