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