1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package securityhub
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/securityhub/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAcceptInvitation struct {
14}
15
16func (*validateOpAcceptInvitation) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAcceptInvitation) 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.(*AcceptInvitationInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAcceptInvitationInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpBatchDisableStandards struct {
34}
35
36func (*validateOpBatchDisableStandards) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpBatchDisableStandards) 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.(*BatchDisableStandardsInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpBatchDisableStandardsInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpBatchEnableStandards struct {
54}
55
56func (*validateOpBatchEnableStandards) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpBatchEnableStandards) 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.(*BatchEnableStandardsInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpBatchEnableStandardsInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpBatchImportFindings struct {
74}
75
76func (*validateOpBatchImportFindings) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpBatchImportFindings) 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.(*BatchImportFindingsInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpBatchImportFindingsInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpBatchUpdateFindings struct {
94}
95
96func (*validateOpBatchUpdateFindings) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpBatchUpdateFindings) 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.(*BatchUpdateFindingsInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpBatchUpdateFindingsInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateActionTarget struct {
114}
115
116func (*validateOpCreateActionTarget) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateActionTarget) 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.(*CreateActionTargetInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateActionTargetInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpCreateInsight struct {
134}
135
136func (*validateOpCreateInsight) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpCreateInsight) 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.(*CreateInsightInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpCreateInsightInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpCreateMembers struct {
154}
155
156func (*validateOpCreateMembers) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpCreateMembers) 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.(*CreateMembersInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpCreateMembersInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDeclineInvitations struct {
174}
175
176func (*validateOpDeclineInvitations) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDeclineInvitations) 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.(*DeclineInvitationsInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDeclineInvitationsInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDeleteActionTarget struct {
194}
195
196func (*validateOpDeleteActionTarget) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDeleteActionTarget) 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.(*DeleteActionTargetInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDeleteActionTargetInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpDeleteInsight struct {
214}
215
216func (*validateOpDeleteInsight) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpDeleteInsight) 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.(*DeleteInsightInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpDeleteInsightInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDeleteInvitations struct {
234}
235
236func (*validateOpDeleteInvitations) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDeleteInvitations) 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.(*DeleteInvitationsInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDeleteInvitationsInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDeleteMembers struct {
254}
255
256func (*validateOpDeleteMembers) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDeleteMembers) 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.(*DeleteMembersInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDeleteMembersInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDescribeStandardsControls struct {
274}
275
276func (*validateOpDescribeStandardsControls) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDescribeStandardsControls) 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.(*DescribeStandardsControlsInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDescribeStandardsControlsInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDisableImportFindingsForProduct struct {
294}
295
296func (*validateOpDisableImportFindingsForProduct) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDisableImportFindingsForProduct) 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.(*DisableImportFindingsForProductInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDisableImportFindingsForProductInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDisableOrganizationAdminAccount struct {
314}
315
316func (*validateOpDisableOrganizationAdminAccount) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDisableOrganizationAdminAccount) 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.(*DisableOrganizationAdminAccountInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDisableOrganizationAdminAccountInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDisassociateMembers struct {
334}
335
336func (*validateOpDisassociateMembers) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDisassociateMembers) 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.(*DisassociateMembersInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDisassociateMembersInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpEnableImportFindingsForProduct struct {
354}
355
356func (*validateOpEnableImportFindingsForProduct) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpEnableImportFindingsForProduct) 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.(*EnableImportFindingsForProductInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpEnableImportFindingsForProductInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpEnableOrganizationAdminAccount struct {
374}
375
376func (*validateOpEnableOrganizationAdminAccount) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpEnableOrganizationAdminAccount) 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.(*EnableOrganizationAdminAccountInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpEnableOrganizationAdminAccountInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpGetInsightResults struct {
394}
395
396func (*validateOpGetInsightResults) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpGetInsightResults) 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.(*GetInsightResultsInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpGetInsightResultsInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpGetMembers struct {
414}
415
416func (*validateOpGetMembers) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpGetMembers) 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.(*GetMembersInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpGetMembersInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpInviteMembers struct {
434}
435
436func (*validateOpInviteMembers) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpInviteMembers) 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.(*InviteMembersInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpInviteMembersInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpListTagsForResource struct {
454}
455
456func (*validateOpListTagsForResource) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpListTagsForResourceInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpTagResource struct {
474}
475
476func (*validateOpTagResource) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpTagResource) 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.(*TagResourceInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpTagResourceInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpUntagResource struct {
494}
495
496func (*validateOpUntagResource) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpUntagResource) 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.(*UntagResourceInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpUntagResourceInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpUpdateActionTarget struct {
514}
515
516func (*validateOpUpdateActionTarget) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpUpdateActionTarget) 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.(*UpdateActionTargetInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpUpdateActionTargetInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpUpdateFindings struct {
534}
535
536func (*validateOpUpdateFindings) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpUpdateFindings) 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.(*UpdateFindingsInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpUpdateFindingsInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpUpdateInsight struct {
554}
555
556func (*validateOpUpdateInsight) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpUpdateInsight) 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.(*UpdateInsightInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpUpdateInsightInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpUpdateOrganizationConfiguration struct {
574}
575
576func (*validateOpUpdateOrganizationConfiguration) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpUpdateOrganizationConfiguration) 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.(*UpdateOrganizationConfigurationInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpUpdateOrganizationConfigurationInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpUpdateStandardsControl struct {
594}
595
596func (*validateOpUpdateStandardsControl) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpUpdateStandardsControl) 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.(*UpdateStandardsControlInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpUpdateStandardsControlInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613func addOpAcceptInvitationValidationMiddleware(stack *middleware.Stack) error {
614	return stack.Initialize.Add(&validateOpAcceptInvitation{}, middleware.After)
615}
616
617func addOpBatchDisableStandardsValidationMiddleware(stack *middleware.Stack) error {
618	return stack.Initialize.Add(&validateOpBatchDisableStandards{}, middleware.After)
619}
620
621func addOpBatchEnableStandardsValidationMiddleware(stack *middleware.Stack) error {
622	return stack.Initialize.Add(&validateOpBatchEnableStandards{}, middleware.After)
623}
624
625func addOpBatchImportFindingsValidationMiddleware(stack *middleware.Stack) error {
626	return stack.Initialize.Add(&validateOpBatchImportFindings{}, middleware.After)
627}
628
629func addOpBatchUpdateFindingsValidationMiddleware(stack *middleware.Stack) error {
630	return stack.Initialize.Add(&validateOpBatchUpdateFindings{}, middleware.After)
631}
632
633func addOpCreateActionTargetValidationMiddleware(stack *middleware.Stack) error {
634	return stack.Initialize.Add(&validateOpCreateActionTarget{}, middleware.After)
635}
636
637func addOpCreateInsightValidationMiddleware(stack *middleware.Stack) error {
638	return stack.Initialize.Add(&validateOpCreateInsight{}, middleware.After)
639}
640
641func addOpCreateMembersValidationMiddleware(stack *middleware.Stack) error {
642	return stack.Initialize.Add(&validateOpCreateMembers{}, middleware.After)
643}
644
645func addOpDeclineInvitationsValidationMiddleware(stack *middleware.Stack) error {
646	return stack.Initialize.Add(&validateOpDeclineInvitations{}, middleware.After)
647}
648
649func addOpDeleteActionTargetValidationMiddleware(stack *middleware.Stack) error {
650	return stack.Initialize.Add(&validateOpDeleteActionTarget{}, middleware.After)
651}
652
653func addOpDeleteInsightValidationMiddleware(stack *middleware.Stack) error {
654	return stack.Initialize.Add(&validateOpDeleteInsight{}, middleware.After)
655}
656
657func addOpDeleteInvitationsValidationMiddleware(stack *middleware.Stack) error {
658	return stack.Initialize.Add(&validateOpDeleteInvitations{}, middleware.After)
659}
660
661func addOpDeleteMembersValidationMiddleware(stack *middleware.Stack) error {
662	return stack.Initialize.Add(&validateOpDeleteMembers{}, middleware.After)
663}
664
665func addOpDescribeStandardsControlsValidationMiddleware(stack *middleware.Stack) error {
666	return stack.Initialize.Add(&validateOpDescribeStandardsControls{}, middleware.After)
667}
668
669func addOpDisableImportFindingsForProductValidationMiddleware(stack *middleware.Stack) error {
670	return stack.Initialize.Add(&validateOpDisableImportFindingsForProduct{}, middleware.After)
671}
672
673func addOpDisableOrganizationAdminAccountValidationMiddleware(stack *middleware.Stack) error {
674	return stack.Initialize.Add(&validateOpDisableOrganizationAdminAccount{}, middleware.After)
675}
676
677func addOpDisassociateMembersValidationMiddleware(stack *middleware.Stack) error {
678	return stack.Initialize.Add(&validateOpDisassociateMembers{}, middleware.After)
679}
680
681func addOpEnableImportFindingsForProductValidationMiddleware(stack *middleware.Stack) error {
682	return stack.Initialize.Add(&validateOpEnableImportFindingsForProduct{}, middleware.After)
683}
684
685func addOpEnableOrganizationAdminAccountValidationMiddleware(stack *middleware.Stack) error {
686	return stack.Initialize.Add(&validateOpEnableOrganizationAdminAccount{}, middleware.After)
687}
688
689func addOpGetInsightResultsValidationMiddleware(stack *middleware.Stack) error {
690	return stack.Initialize.Add(&validateOpGetInsightResults{}, middleware.After)
691}
692
693func addOpGetMembersValidationMiddleware(stack *middleware.Stack) error {
694	return stack.Initialize.Add(&validateOpGetMembers{}, middleware.After)
695}
696
697func addOpInviteMembersValidationMiddleware(stack *middleware.Stack) error {
698	return stack.Initialize.Add(&validateOpInviteMembers{}, middleware.After)
699}
700
701func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
702	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
703}
704
705func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
706	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
707}
708
709func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
710	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
711}
712
713func addOpUpdateActionTargetValidationMiddleware(stack *middleware.Stack) error {
714	return stack.Initialize.Add(&validateOpUpdateActionTarget{}, middleware.After)
715}
716
717func addOpUpdateFindingsValidationMiddleware(stack *middleware.Stack) error {
718	return stack.Initialize.Add(&validateOpUpdateFindings{}, middleware.After)
719}
720
721func addOpUpdateInsightValidationMiddleware(stack *middleware.Stack) error {
722	return stack.Initialize.Add(&validateOpUpdateInsight{}, middleware.After)
723}
724
725func addOpUpdateOrganizationConfigurationValidationMiddleware(stack *middleware.Stack) error {
726	return stack.Initialize.Add(&validateOpUpdateOrganizationConfiguration{}, middleware.After)
727}
728
729func addOpUpdateStandardsControlValidationMiddleware(stack *middleware.Stack) error {
730	return stack.Initialize.Add(&validateOpUpdateStandardsControl{}, middleware.After)
731}
732
733func validateAccountDetails(v *types.AccountDetails) error {
734	if v == nil {
735		return nil
736	}
737	invalidParams := smithy.InvalidParamsError{Context: "AccountDetails"}
738	if v.AccountId == nil {
739		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
740	}
741	if invalidParams.Len() > 0 {
742		return invalidParams
743	} else {
744		return nil
745	}
746}
747
748func validateAccountDetailsList(v []types.AccountDetails) error {
749	if v == nil {
750		return nil
751	}
752	invalidParams := smithy.InvalidParamsError{Context: "AccountDetailsList"}
753	for i := range v {
754		if err := validateAccountDetails(&v[i]); err != nil {
755			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
756		}
757	}
758	if invalidParams.Len() > 0 {
759		return invalidParams
760	} else {
761		return nil
762	}
763}
764
765func validateAwsSecurityFinding(v *types.AwsSecurityFinding) error {
766	if v == nil {
767		return nil
768	}
769	invalidParams := smithy.InvalidParamsError{Context: "AwsSecurityFinding"}
770	if v.SchemaVersion == nil {
771		invalidParams.Add(smithy.NewErrParamRequired("SchemaVersion"))
772	}
773	if v.Id == nil {
774		invalidParams.Add(smithy.NewErrParamRequired("Id"))
775	}
776	if v.ProductArn == nil {
777		invalidParams.Add(smithy.NewErrParamRequired("ProductArn"))
778	}
779	if v.GeneratorId == nil {
780		invalidParams.Add(smithy.NewErrParamRequired("GeneratorId"))
781	}
782	if v.AwsAccountId == nil {
783		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
784	}
785	if v.Types == nil {
786		invalidParams.Add(smithy.NewErrParamRequired("Types"))
787	}
788	if v.CreatedAt == nil {
789		invalidParams.Add(smithy.NewErrParamRequired("CreatedAt"))
790	}
791	if v.UpdatedAt == nil {
792		invalidParams.Add(smithy.NewErrParamRequired("UpdatedAt"))
793	}
794	if v.Severity == nil {
795		invalidParams.Add(smithy.NewErrParamRequired("Severity"))
796	}
797	if v.Title == nil {
798		invalidParams.Add(smithy.NewErrParamRequired("Title"))
799	}
800	if v.Description == nil {
801		invalidParams.Add(smithy.NewErrParamRequired("Description"))
802	}
803	if v.Malware != nil {
804		if err := validateMalwareList(v.Malware); err != nil {
805			invalidParams.AddNested("Malware", err.(smithy.InvalidParamsError))
806		}
807	}
808	if v.Resources == nil {
809		invalidParams.Add(smithy.NewErrParamRequired("Resources"))
810	} else if v.Resources != nil {
811		if err := validateResourceList(v.Resources); err != nil {
812			invalidParams.AddNested("Resources", err.(smithy.InvalidParamsError))
813		}
814	}
815	if v.Compliance != nil {
816		if err := validateCompliance(v.Compliance); err != nil {
817			invalidParams.AddNested("Compliance", err.(smithy.InvalidParamsError))
818		}
819	}
820	if v.RelatedFindings != nil {
821		if err := validateRelatedFindingList(v.RelatedFindings); err != nil {
822			invalidParams.AddNested("RelatedFindings", err.(smithy.InvalidParamsError))
823		}
824	}
825	if v.Note != nil {
826		if err := validateNote(v.Note); err != nil {
827			invalidParams.AddNested("Note", err.(smithy.InvalidParamsError))
828		}
829	}
830	if v.Vulnerabilities != nil {
831		if err := validateVulnerabilityList(v.Vulnerabilities); err != nil {
832			invalidParams.AddNested("Vulnerabilities", err.(smithy.InvalidParamsError))
833		}
834	}
835	if v.PatchSummary != nil {
836		if err := validatePatchSummary(v.PatchSummary); err != nil {
837			invalidParams.AddNested("PatchSummary", err.(smithy.InvalidParamsError))
838		}
839	}
840	if invalidParams.Len() > 0 {
841		return invalidParams
842	} else {
843		return nil
844	}
845}
846
847func validateAwsSecurityFindingIdentifier(v *types.AwsSecurityFindingIdentifier) error {
848	if v == nil {
849		return nil
850	}
851	invalidParams := smithy.InvalidParamsError{Context: "AwsSecurityFindingIdentifier"}
852	if v.Id == nil {
853		invalidParams.Add(smithy.NewErrParamRequired("Id"))
854	}
855	if v.ProductArn == nil {
856		invalidParams.Add(smithy.NewErrParamRequired("ProductArn"))
857	}
858	if invalidParams.Len() > 0 {
859		return invalidParams
860	} else {
861		return nil
862	}
863}
864
865func validateAwsSecurityFindingIdentifierList(v []types.AwsSecurityFindingIdentifier) error {
866	if v == nil {
867		return nil
868	}
869	invalidParams := smithy.InvalidParamsError{Context: "AwsSecurityFindingIdentifierList"}
870	for i := range v {
871		if err := validateAwsSecurityFindingIdentifier(&v[i]); err != nil {
872			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
873		}
874	}
875	if invalidParams.Len() > 0 {
876		return invalidParams
877	} else {
878		return nil
879	}
880}
881
882func validateAwsSecurityFindingList(v []types.AwsSecurityFinding) error {
883	if v == nil {
884		return nil
885	}
886	invalidParams := smithy.InvalidParamsError{Context: "AwsSecurityFindingList"}
887	for i := range v {
888		if err := validateAwsSecurityFinding(&v[i]); err != nil {
889			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
890		}
891	}
892	if invalidParams.Len() > 0 {
893		return invalidParams
894	} else {
895		return nil
896	}
897}
898
899func validateCompliance(v *types.Compliance) error {
900	if v == nil {
901		return nil
902	}
903	invalidParams := smithy.InvalidParamsError{Context: "Compliance"}
904	if v.StatusReasons != nil {
905		if err := validateStatusReasonsList(v.StatusReasons); err != nil {
906			invalidParams.AddNested("StatusReasons", err.(smithy.InvalidParamsError))
907		}
908	}
909	if invalidParams.Len() > 0 {
910		return invalidParams
911	} else {
912		return nil
913	}
914}
915
916func validateMalware(v *types.Malware) error {
917	if v == nil {
918		return nil
919	}
920	invalidParams := smithy.InvalidParamsError{Context: "Malware"}
921	if v.Name == nil {
922		invalidParams.Add(smithy.NewErrParamRequired("Name"))
923	}
924	if invalidParams.Len() > 0 {
925		return invalidParams
926	} else {
927		return nil
928	}
929}
930
931func validateMalwareList(v []types.Malware) error {
932	if v == nil {
933		return nil
934	}
935	invalidParams := smithy.InvalidParamsError{Context: "MalwareList"}
936	for i := range v {
937		if err := validateMalware(&v[i]); err != nil {
938			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
939		}
940	}
941	if invalidParams.Len() > 0 {
942		return invalidParams
943	} else {
944		return nil
945	}
946}
947
948func validateNote(v *types.Note) error {
949	if v == nil {
950		return nil
951	}
952	invalidParams := smithy.InvalidParamsError{Context: "Note"}
953	if v.Text == nil {
954		invalidParams.Add(smithy.NewErrParamRequired("Text"))
955	}
956	if v.UpdatedBy == nil {
957		invalidParams.Add(smithy.NewErrParamRequired("UpdatedBy"))
958	}
959	if v.UpdatedAt == nil {
960		invalidParams.Add(smithy.NewErrParamRequired("UpdatedAt"))
961	}
962	if invalidParams.Len() > 0 {
963		return invalidParams
964	} else {
965		return nil
966	}
967}
968
969func validateNoteUpdate(v *types.NoteUpdate) error {
970	if v == nil {
971		return nil
972	}
973	invalidParams := smithy.InvalidParamsError{Context: "NoteUpdate"}
974	if v.Text == nil {
975		invalidParams.Add(smithy.NewErrParamRequired("Text"))
976	}
977	if v.UpdatedBy == nil {
978		invalidParams.Add(smithy.NewErrParamRequired("UpdatedBy"))
979	}
980	if invalidParams.Len() > 0 {
981		return invalidParams
982	} else {
983		return nil
984	}
985}
986
987func validatePatchSummary(v *types.PatchSummary) error {
988	if v == nil {
989		return nil
990	}
991	invalidParams := smithy.InvalidParamsError{Context: "PatchSummary"}
992	if v.Id == nil {
993		invalidParams.Add(smithy.NewErrParamRequired("Id"))
994	}
995	if invalidParams.Len() > 0 {
996		return invalidParams
997	} else {
998		return nil
999	}
1000}
1001
1002func validateRelatedFinding(v *types.RelatedFinding) error {
1003	if v == nil {
1004		return nil
1005	}
1006	invalidParams := smithy.InvalidParamsError{Context: "RelatedFinding"}
1007	if v.ProductArn == nil {
1008		invalidParams.Add(smithy.NewErrParamRequired("ProductArn"))
1009	}
1010	if v.Id == nil {
1011		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1012	}
1013	if invalidParams.Len() > 0 {
1014		return invalidParams
1015	} else {
1016		return nil
1017	}
1018}
1019
1020func validateRelatedFindingList(v []types.RelatedFinding) error {
1021	if v == nil {
1022		return nil
1023	}
1024	invalidParams := smithy.InvalidParamsError{Context: "RelatedFindingList"}
1025	for i := range v {
1026		if err := validateRelatedFinding(&v[i]); err != nil {
1027			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1028		}
1029	}
1030	if invalidParams.Len() > 0 {
1031		return invalidParams
1032	} else {
1033		return nil
1034	}
1035}
1036
1037func validateResource(v *types.Resource) error {
1038	if v == nil {
1039		return nil
1040	}
1041	invalidParams := smithy.InvalidParamsError{Context: "Resource"}
1042	if v.Type == nil {
1043		invalidParams.Add(smithy.NewErrParamRequired("Type"))
1044	}
1045	if v.Id == nil {
1046		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1047	}
1048	if invalidParams.Len() > 0 {
1049		return invalidParams
1050	} else {
1051		return nil
1052	}
1053}
1054
1055func validateResourceList(v []types.Resource) error {
1056	if v == nil {
1057		return nil
1058	}
1059	invalidParams := smithy.InvalidParamsError{Context: "ResourceList"}
1060	for i := range v {
1061		if err := validateResource(&v[i]); err != nil {
1062			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1063		}
1064	}
1065	if invalidParams.Len() > 0 {
1066		return invalidParams
1067	} else {
1068		return nil
1069	}
1070}
1071
1072func validateStandardsSubscriptionRequest(v *types.StandardsSubscriptionRequest) error {
1073	if v == nil {
1074		return nil
1075	}
1076	invalidParams := smithy.InvalidParamsError{Context: "StandardsSubscriptionRequest"}
1077	if v.StandardsArn == nil {
1078		invalidParams.Add(smithy.NewErrParamRequired("StandardsArn"))
1079	}
1080	if invalidParams.Len() > 0 {
1081		return invalidParams
1082	} else {
1083		return nil
1084	}
1085}
1086
1087func validateStandardsSubscriptionRequests(v []types.StandardsSubscriptionRequest) error {
1088	if v == nil {
1089		return nil
1090	}
1091	invalidParams := smithy.InvalidParamsError{Context: "StandardsSubscriptionRequests"}
1092	for i := range v {
1093		if err := validateStandardsSubscriptionRequest(&v[i]); err != nil {
1094			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1095		}
1096	}
1097	if invalidParams.Len() > 0 {
1098		return invalidParams
1099	} else {
1100		return nil
1101	}
1102}
1103
1104func validateStatusReason(v *types.StatusReason) error {
1105	if v == nil {
1106		return nil
1107	}
1108	invalidParams := smithy.InvalidParamsError{Context: "StatusReason"}
1109	if v.ReasonCode == nil {
1110		invalidParams.Add(smithy.NewErrParamRequired("ReasonCode"))
1111	}
1112	if invalidParams.Len() > 0 {
1113		return invalidParams
1114	} else {
1115		return nil
1116	}
1117}
1118
1119func validateStatusReasonsList(v []types.StatusReason) error {
1120	if v == nil {
1121		return nil
1122	}
1123	invalidParams := smithy.InvalidParamsError{Context: "StatusReasonsList"}
1124	for i := range v {
1125		if err := validateStatusReason(&v[i]); err != nil {
1126			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1127		}
1128	}
1129	if invalidParams.Len() > 0 {
1130		return invalidParams
1131	} else {
1132		return nil
1133	}
1134}
1135
1136func validateVulnerability(v *types.Vulnerability) error {
1137	if v == nil {
1138		return nil
1139	}
1140	invalidParams := smithy.InvalidParamsError{Context: "Vulnerability"}
1141	if v.Id == nil {
1142		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1143	}
1144	if v.Vendor != nil {
1145		if err := validateVulnerabilityVendor(v.Vendor); err != nil {
1146			invalidParams.AddNested("Vendor", err.(smithy.InvalidParamsError))
1147		}
1148	}
1149	if invalidParams.Len() > 0 {
1150		return invalidParams
1151	} else {
1152		return nil
1153	}
1154}
1155
1156func validateVulnerabilityList(v []types.Vulnerability) error {
1157	if v == nil {
1158		return nil
1159	}
1160	invalidParams := smithy.InvalidParamsError{Context: "VulnerabilityList"}
1161	for i := range v {
1162		if err := validateVulnerability(&v[i]); err != nil {
1163			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1164		}
1165	}
1166	if invalidParams.Len() > 0 {
1167		return invalidParams
1168	} else {
1169		return nil
1170	}
1171}
1172
1173func validateVulnerabilityVendor(v *types.VulnerabilityVendor) error {
1174	if v == nil {
1175		return nil
1176	}
1177	invalidParams := smithy.InvalidParamsError{Context: "VulnerabilityVendor"}
1178	if v.Name == nil {
1179		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1180	}
1181	if invalidParams.Len() > 0 {
1182		return invalidParams
1183	} else {
1184		return nil
1185	}
1186}
1187
1188func validateOpAcceptInvitationInput(v *AcceptInvitationInput) error {
1189	if v == nil {
1190		return nil
1191	}
1192	invalidParams := smithy.InvalidParamsError{Context: "AcceptInvitationInput"}
1193	if v.MasterId == nil {
1194		invalidParams.Add(smithy.NewErrParamRequired("MasterId"))
1195	}
1196	if v.InvitationId == nil {
1197		invalidParams.Add(smithy.NewErrParamRequired("InvitationId"))
1198	}
1199	if invalidParams.Len() > 0 {
1200		return invalidParams
1201	} else {
1202		return nil
1203	}
1204}
1205
1206func validateOpBatchDisableStandardsInput(v *BatchDisableStandardsInput) error {
1207	if v == nil {
1208		return nil
1209	}
1210	invalidParams := smithy.InvalidParamsError{Context: "BatchDisableStandardsInput"}
1211	if v.StandardsSubscriptionArns == nil {
1212		invalidParams.Add(smithy.NewErrParamRequired("StandardsSubscriptionArns"))
1213	}
1214	if invalidParams.Len() > 0 {
1215		return invalidParams
1216	} else {
1217		return nil
1218	}
1219}
1220
1221func validateOpBatchEnableStandardsInput(v *BatchEnableStandardsInput) error {
1222	if v == nil {
1223		return nil
1224	}
1225	invalidParams := smithy.InvalidParamsError{Context: "BatchEnableStandardsInput"}
1226	if v.StandardsSubscriptionRequests == nil {
1227		invalidParams.Add(smithy.NewErrParamRequired("StandardsSubscriptionRequests"))
1228	} else if v.StandardsSubscriptionRequests != nil {
1229		if err := validateStandardsSubscriptionRequests(v.StandardsSubscriptionRequests); err != nil {
1230			invalidParams.AddNested("StandardsSubscriptionRequests", err.(smithy.InvalidParamsError))
1231		}
1232	}
1233	if invalidParams.Len() > 0 {
1234		return invalidParams
1235	} else {
1236		return nil
1237	}
1238}
1239
1240func validateOpBatchImportFindingsInput(v *BatchImportFindingsInput) error {
1241	if v == nil {
1242		return nil
1243	}
1244	invalidParams := smithy.InvalidParamsError{Context: "BatchImportFindingsInput"}
1245	if v.Findings == nil {
1246		invalidParams.Add(smithy.NewErrParamRequired("Findings"))
1247	} else if v.Findings != nil {
1248		if err := validateAwsSecurityFindingList(v.Findings); err != nil {
1249			invalidParams.AddNested("Findings", err.(smithy.InvalidParamsError))
1250		}
1251	}
1252	if invalidParams.Len() > 0 {
1253		return invalidParams
1254	} else {
1255		return nil
1256	}
1257}
1258
1259func validateOpBatchUpdateFindingsInput(v *BatchUpdateFindingsInput) error {
1260	if v == nil {
1261		return nil
1262	}
1263	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateFindingsInput"}
1264	if v.FindingIdentifiers == nil {
1265		invalidParams.Add(smithy.NewErrParamRequired("FindingIdentifiers"))
1266	} else if v.FindingIdentifiers != nil {
1267		if err := validateAwsSecurityFindingIdentifierList(v.FindingIdentifiers); err != nil {
1268			invalidParams.AddNested("FindingIdentifiers", err.(smithy.InvalidParamsError))
1269		}
1270	}
1271	if v.Note != nil {
1272		if err := validateNoteUpdate(v.Note); err != nil {
1273			invalidParams.AddNested("Note", err.(smithy.InvalidParamsError))
1274		}
1275	}
1276	if v.RelatedFindings != nil {
1277		if err := validateRelatedFindingList(v.RelatedFindings); err != nil {
1278			invalidParams.AddNested("RelatedFindings", err.(smithy.InvalidParamsError))
1279		}
1280	}
1281	if invalidParams.Len() > 0 {
1282		return invalidParams
1283	} else {
1284		return nil
1285	}
1286}
1287
1288func validateOpCreateActionTargetInput(v *CreateActionTargetInput) error {
1289	if v == nil {
1290		return nil
1291	}
1292	invalidParams := smithy.InvalidParamsError{Context: "CreateActionTargetInput"}
1293	if v.Name == nil {
1294		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1295	}
1296	if v.Description == nil {
1297		invalidParams.Add(smithy.NewErrParamRequired("Description"))
1298	}
1299	if v.Id == nil {
1300		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1301	}
1302	if invalidParams.Len() > 0 {
1303		return invalidParams
1304	} else {
1305		return nil
1306	}
1307}
1308
1309func validateOpCreateInsightInput(v *CreateInsightInput) error {
1310	if v == nil {
1311		return nil
1312	}
1313	invalidParams := smithy.InvalidParamsError{Context: "CreateInsightInput"}
1314	if v.Name == nil {
1315		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1316	}
1317	if v.Filters == nil {
1318		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
1319	}
1320	if v.GroupByAttribute == nil {
1321		invalidParams.Add(smithy.NewErrParamRequired("GroupByAttribute"))
1322	}
1323	if invalidParams.Len() > 0 {
1324		return invalidParams
1325	} else {
1326		return nil
1327	}
1328}
1329
1330func validateOpCreateMembersInput(v *CreateMembersInput) error {
1331	if v == nil {
1332		return nil
1333	}
1334	invalidParams := smithy.InvalidParamsError{Context: "CreateMembersInput"}
1335	if v.AccountDetails == nil {
1336		invalidParams.Add(smithy.NewErrParamRequired("AccountDetails"))
1337	} else if v.AccountDetails != nil {
1338		if err := validateAccountDetailsList(v.AccountDetails); err != nil {
1339			invalidParams.AddNested("AccountDetails", err.(smithy.InvalidParamsError))
1340		}
1341	}
1342	if invalidParams.Len() > 0 {
1343		return invalidParams
1344	} else {
1345		return nil
1346	}
1347}
1348
1349func validateOpDeclineInvitationsInput(v *DeclineInvitationsInput) error {
1350	if v == nil {
1351		return nil
1352	}
1353	invalidParams := smithy.InvalidParamsError{Context: "DeclineInvitationsInput"}
1354	if v.AccountIds == nil {
1355		invalidParams.Add(smithy.NewErrParamRequired("AccountIds"))
1356	}
1357	if invalidParams.Len() > 0 {
1358		return invalidParams
1359	} else {
1360		return nil
1361	}
1362}
1363
1364func validateOpDeleteActionTargetInput(v *DeleteActionTargetInput) error {
1365	if v == nil {
1366		return nil
1367	}
1368	invalidParams := smithy.InvalidParamsError{Context: "DeleteActionTargetInput"}
1369	if v.ActionTargetArn == nil {
1370		invalidParams.Add(smithy.NewErrParamRequired("ActionTargetArn"))
1371	}
1372	if invalidParams.Len() > 0 {
1373		return invalidParams
1374	} else {
1375		return nil
1376	}
1377}
1378
1379func validateOpDeleteInsightInput(v *DeleteInsightInput) error {
1380	if v == nil {
1381		return nil
1382	}
1383	invalidParams := smithy.InvalidParamsError{Context: "DeleteInsightInput"}
1384	if v.InsightArn == nil {
1385		invalidParams.Add(smithy.NewErrParamRequired("InsightArn"))
1386	}
1387	if invalidParams.Len() > 0 {
1388		return invalidParams
1389	} else {
1390		return nil
1391	}
1392}
1393
1394func validateOpDeleteInvitationsInput(v *DeleteInvitationsInput) error {
1395	if v == nil {
1396		return nil
1397	}
1398	invalidParams := smithy.InvalidParamsError{Context: "DeleteInvitationsInput"}
1399	if v.AccountIds == nil {
1400		invalidParams.Add(smithy.NewErrParamRequired("AccountIds"))
1401	}
1402	if invalidParams.Len() > 0 {
1403		return invalidParams
1404	} else {
1405		return nil
1406	}
1407}
1408
1409func validateOpDeleteMembersInput(v *DeleteMembersInput) error {
1410	if v == nil {
1411		return nil
1412	}
1413	invalidParams := smithy.InvalidParamsError{Context: "DeleteMembersInput"}
1414	if v.AccountIds == nil {
1415		invalidParams.Add(smithy.NewErrParamRequired("AccountIds"))
1416	}
1417	if invalidParams.Len() > 0 {
1418		return invalidParams
1419	} else {
1420		return nil
1421	}
1422}
1423
1424func validateOpDescribeStandardsControlsInput(v *DescribeStandardsControlsInput) error {
1425	if v == nil {
1426		return nil
1427	}
1428	invalidParams := smithy.InvalidParamsError{Context: "DescribeStandardsControlsInput"}
1429	if v.StandardsSubscriptionArn == nil {
1430		invalidParams.Add(smithy.NewErrParamRequired("StandardsSubscriptionArn"))
1431	}
1432	if invalidParams.Len() > 0 {
1433		return invalidParams
1434	} else {
1435		return nil
1436	}
1437}
1438
1439func validateOpDisableImportFindingsForProductInput(v *DisableImportFindingsForProductInput) error {
1440	if v == nil {
1441		return nil
1442	}
1443	invalidParams := smithy.InvalidParamsError{Context: "DisableImportFindingsForProductInput"}
1444	if v.ProductSubscriptionArn == nil {
1445		invalidParams.Add(smithy.NewErrParamRequired("ProductSubscriptionArn"))
1446	}
1447	if invalidParams.Len() > 0 {
1448		return invalidParams
1449	} else {
1450		return nil
1451	}
1452}
1453
1454func validateOpDisableOrganizationAdminAccountInput(v *DisableOrganizationAdminAccountInput) error {
1455	if v == nil {
1456		return nil
1457	}
1458	invalidParams := smithy.InvalidParamsError{Context: "DisableOrganizationAdminAccountInput"}
1459	if v.AdminAccountId == nil {
1460		invalidParams.Add(smithy.NewErrParamRequired("AdminAccountId"))
1461	}
1462	if invalidParams.Len() > 0 {
1463		return invalidParams
1464	} else {
1465		return nil
1466	}
1467}
1468
1469func validateOpDisassociateMembersInput(v *DisassociateMembersInput) error {
1470	if v == nil {
1471		return nil
1472	}
1473	invalidParams := smithy.InvalidParamsError{Context: "DisassociateMembersInput"}
1474	if v.AccountIds == nil {
1475		invalidParams.Add(smithy.NewErrParamRequired("AccountIds"))
1476	}
1477	if invalidParams.Len() > 0 {
1478		return invalidParams
1479	} else {
1480		return nil
1481	}
1482}
1483
1484func validateOpEnableImportFindingsForProductInput(v *EnableImportFindingsForProductInput) error {
1485	if v == nil {
1486		return nil
1487	}
1488	invalidParams := smithy.InvalidParamsError{Context: "EnableImportFindingsForProductInput"}
1489	if v.ProductArn == nil {
1490		invalidParams.Add(smithy.NewErrParamRequired("ProductArn"))
1491	}
1492	if invalidParams.Len() > 0 {
1493		return invalidParams
1494	} else {
1495		return nil
1496	}
1497}
1498
1499func validateOpEnableOrganizationAdminAccountInput(v *EnableOrganizationAdminAccountInput) error {
1500	if v == nil {
1501		return nil
1502	}
1503	invalidParams := smithy.InvalidParamsError{Context: "EnableOrganizationAdminAccountInput"}
1504	if v.AdminAccountId == nil {
1505		invalidParams.Add(smithy.NewErrParamRequired("AdminAccountId"))
1506	}
1507	if invalidParams.Len() > 0 {
1508		return invalidParams
1509	} else {
1510		return nil
1511	}
1512}
1513
1514func validateOpGetInsightResultsInput(v *GetInsightResultsInput) error {
1515	if v == nil {
1516		return nil
1517	}
1518	invalidParams := smithy.InvalidParamsError{Context: "GetInsightResultsInput"}
1519	if v.InsightArn == nil {
1520		invalidParams.Add(smithy.NewErrParamRequired("InsightArn"))
1521	}
1522	if invalidParams.Len() > 0 {
1523		return invalidParams
1524	} else {
1525		return nil
1526	}
1527}
1528
1529func validateOpGetMembersInput(v *GetMembersInput) error {
1530	if v == nil {
1531		return nil
1532	}
1533	invalidParams := smithy.InvalidParamsError{Context: "GetMembersInput"}
1534	if v.AccountIds == nil {
1535		invalidParams.Add(smithy.NewErrParamRequired("AccountIds"))
1536	}
1537	if invalidParams.Len() > 0 {
1538		return invalidParams
1539	} else {
1540		return nil
1541	}
1542}
1543
1544func validateOpInviteMembersInput(v *InviteMembersInput) error {
1545	if v == nil {
1546		return nil
1547	}
1548	invalidParams := smithy.InvalidParamsError{Context: "InviteMembersInput"}
1549	if v.AccountIds == nil {
1550		invalidParams.Add(smithy.NewErrParamRequired("AccountIds"))
1551	}
1552	if invalidParams.Len() > 0 {
1553		return invalidParams
1554	} else {
1555		return nil
1556	}
1557}
1558
1559func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1560	if v == nil {
1561		return nil
1562	}
1563	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1564	if v.ResourceArn == nil {
1565		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1566	}
1567	if invalidParams.Len() > 0 {
1568		return invalidParams
1569	} else {
1570		return nil
1571	}
1572}
1573
1574func validateOpTagResourceInput(v *TagResourceInput) error {
1575	if v == nil {
1576		return nil
1577	}
1578	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
1579	if v.ResourceArn == nil {
1580		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1581	}
1582	if v.Tags == nil {
1583		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1584	}
1585	if invalidParams.Len() > 0 {
1586		return invalidParams
1587	} else {
1588		return nil
1589	}
1590}
1591
1592func validateOpUntagResourceInput(v *UntagResourceInput) error {
1593	if v == nil {
1594		return nil
1595	}
1596	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
1597	if v.ResourceArn == nil {
1598		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1599	}
1600	if v.TagKeys == nil {
1601		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1602	}
1603	if invalidParams.Len() > 0 {
1604		return invalidParams
1605	} else {
1606		return nil
1607	}
1608}
1609
1610func validateOpUpdateActionTargetInput(v *UpdateActionTargetInput) error {
1611	if v == nil {
1612		return nil
1613	}
1614	invalidParams := smithy.InvalidParamsError{Context: "UpdateActionTargetInput"}
1615	if v.ActionTargetArn == nil {
1616		invalidParams.Add(smithy.NewErrParamRequired("ActionTargetArn"))
1617	}
1618	if invalidParams.Len() > 0 {
1619		return invalidParams
1620	} else {
1621		return nil
1622	}
1623}
1624
1625func validateOpUpdateFindingsInput(v *UpdateFindingsInput) error {
1626	if v == nil {
1627		return nil
1628	}
1629	invalidParams := smithy.InvalidParamsError{Context: "UpdateFindingsInput"}
1630	if v.Filters == nil {
1631		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
1632	}
1633	if v.Note != nil {
1634		if err := validateNoteUpdate(v.Note); err != nil {
1635			invalidParams.AddNested("Note", err.(smithy.InvalidParamsError))
1636		}
1637	}
1638	if invalidParams.Len() > 0 {
1639		return invalidParams
1640	} else {
1641		return nil
1642	}
1643}
1644
1645func validateOpUpdateInsightInput(v *UpdateInsightInput) error {
1646	if v == nil {
1647		return nil
1648	}
1649	invalidParams := smithy.InvalidParamsError{Context: "UpdateInsightInput"}
1650	if v.InsightArn == nil {
1651		invalidParams.Add(smithy.NewErrParamRequired("InsightArn"))
1652	}
1653	if invalidParams.Len() > 0 {
1654		return invalidParams
1655	} else {
1656		return nil
1657	}
1658}
1659
1660func validateOpUpdateOrganizationConfigurationInput(v *UpdateOrganizationConfigurationInput) error {
1661	if v == nil {
1662		return nil
1663	}
1664	invalidParams := smithy.InvalidParamsError{Context: "UpdateOrganizationConfigurationInput"}
1665	if invalidParams.Len() > 0 {
1666		return invalidParams
1667	} else {
1668		return nil
1669	}
1670}
1671
1672func validateOpUpdateStandardsControlInput(v *UpdateStandardsControlInput) error {
1673	if v == nil {
1674		return nil
1675	}
1676	invalidParams := smithy.InvalidParamsError{Context: "UpdateStandardsControlInput"}
1677	if v.StandardsControlArn == nil {
1678		invalidParams.Add(smithy.NewErrParamRequired("StandardsControlArn"))
1679	}
1680	if invalidParams.Len() > 0 {
1681		return invalidParams
1682	} else {
1683		return nil
1684	}
1685}
1686