1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package cognitoidentity
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/cognitoidentity/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCreateIdentityPool struct {
14}
15
16func (*validateOpCreateIdentityPool) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCreateIdentityPool) 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.(*CreateIdentityPoolInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCreateIdentityPoolInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpDeleteIdentities struct {
34}
35
36func (*validateOpDeleteIdentities) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpDeleteIdentities) 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.(*DeleteIdentitiesInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpDeleteIdentitiesInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpDeleteIdentityPool struct {
54}
55
56func (*validateOpDeleteIdentityPool) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpDeleteIdentityPool) 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.(*DeleteIdentityPoolInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpDeleteIdentityPoolInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpDescribeIdentity struct {
74}
75
76func (*validateOpDescribeIdentity) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpDescribeIdentity) 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.(*DescribeIdentityInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpDescribeIdentityInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpDescribeIdentityPool struct {
94}
95
96func (*validateOpDescribeIdentityPool) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpDescribeIdentityPool) 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.(*DescribeIdentityPoolInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpDescribeIdentityPoolInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpGetCredentialsForIdentity struct {
114}
115
116func (*validateOpGetCredentialsForIdentity) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpGetCredentialsForIdentity) 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.(*GetCredentialsForIdentityInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpGetCredentialsForIdentityInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpGetIdentityPoolRoles struct {
134}
135
136func (*validateOpGetIdentityPoolRoles) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpGetIdentityPoolRoles) 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.(*GetIdentityPoolRolesInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpGetIdentityPoolRolesInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpGetId struct {
154}
155
156func (*validateOpGetId) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpGetId) 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.(*GetIdInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpGetIdInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpGetOpenIdTokenForDeveloperIdentity struct {
174}
175
176func (*validateOpGetOpenIdTokenForDeveloperIdentity) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpGetOpenIdTokenForDeveloperIdentity) 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.(*GetOpenIdTokenForDeveloperIdentityInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpGetOpenIdTokenForDeveloperIdentityInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpGetOpenIdToken struct {
194}
195
196func (*validateOpGetOpenIdToken) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpGetOpenIdToken) 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.(*GetOpenIdTokenInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpGetOpenIdTokenInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpGetPrincipalTagAttributeMap struct {
214}
215
216func (*validateOpGetPrincipalTagAttributeMap) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpGetPrincipalTagAttributeMap) 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.(*GetPrincipalTagAttributeMapInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpGetPrincipalTagAttributeMapInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpListIdentities struct {
234}
235
236func (*validateOpListIdentities) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpListIdentities) 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.(*ListIdentitiesInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpListIdentitiesInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpListIdentityPools struct {
254}
255
256func (*validateOpListIdentityPools) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpListIdentityPools) 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.(*ListIdentityPoolsInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpListIdentityPoolsInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpListTagsForResource struct {
274}
275
276func (*validateOpListTagsForResource) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpListTagsForResourceInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpLookupDeveloperIdentity struct {
294}
295
296func (*validateOpLookupDeveloperIdentity) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpLookupDeveloperIdentity) 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.(*LookupDeveloperIdentityInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpLookupDeveloperIdentityInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpMergeDeveloperIdentities struct {
314}
315
316func (*validateOpMergeDeveloperIdentities) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpMergeDeveloperIdentities) 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.(*MergeDeveloperIdentitiesInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpMergeDeveloperIdentitiesInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpSetIdentityPoolRoles struct {
334}
335
336func (*validateOpSetIdentityPoolRoles) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpSetIdentityPoolRoles) 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.(*SetIdentityPoolRolesInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpSetIdentityPoolRolesInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpSetPrincipalTagAttributeMap struct {
354}
355
356func (*validateOpSetPrincipalTagAttributeMap) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpSetPrincipalTagAttributeMap) 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.(*SetPrincipalTagAttributeMapInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpSetPrincipalTagAttributeMapInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpTagResource struct {
374}
375
376func (*validateOpTagResource) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpTagResource) 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.(*TagResourceInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpTagResourceInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpUnlinkDeveloperIdentity struct {
394}
395
396func (*validateOpUnlinkDeveloperIdentity) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpUnlinkDeveloperIdentity) 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.(*UnlinkDeveloperIdentityInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpUnlinkDeveloperIdentityInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpUnlinkIdentity struct {
414}
415
416func (*validateOpUnlinkIdentity) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpUnlinkIdentity) 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.(*UnlinkIdentityInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpUnlinkIdentityInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpUntagResource struct {
434}
435
436func (*validateOpUntagResource) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpUntagResource) 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.(*UntagResourceInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpUntagResourceInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpUpdateIdentityPool struct {
454}
455
456func (*validateOpUpdateIdentityPool) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpUpdateIdentityPool) 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.(*UpdateIdentityPoolInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpUpdateIdentityPoolInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473func addOpCreateIdentityPoolValidationMiddleware(stack *middleware.Stack) error {
474	return stack.Initialize.Add(&validateOpCreateIdentityPool{}, middleware.After)
475}
476
477func addOpDeleteIdentitiesValidationMiddleware(stack *middleware.Stack) error {
478	return stack.Initialize.Add(&validateOpDeleteIdentities{}, middleware.After)
479}
480
481func addOpDeleteIdentityPoolValidationMiddleware(stack *middleware.Stack) error {
482	return stack.Initialize.Add(&validateOpDeleteIdentityPool{}, middleware.After)
483}
484
485func addOpDescribeIdentityValidationMiddleware(stack *middleware.Stack) error {
486	return stack.Initialize.Add(&validateOpDescribeIdentity{}, middleware.After)
487}
488
489func addOpDescribeIdentityPoolValidationMiddleware(stack *middleware.Stack) error {
490	return stack.Initialize.Add(&validateOpDescribeIdentityPool{}, middleware.After)
491}
492
493func addOpGetCredentialsForIdentityValidationMiddleware(stack *middleware.Stack) error {
494	return stack.Initialize.Add(&validateOpGetCredentialsForIdentity{}, middleware.After)
495}
496
497func addOpGetIdentityPoolRolesValidationMiddleware(stack *middleware.Stack) error {
498	return stack.Initialize.Add(&validateOpGetIdentityPoolRoles{}, middleware.After)
499}
500
501func addOpGetIdValidationMiddleware(stack *middleware.Stack) error {
502	return stack.Initialize.Add(&validateOpGetId{}, middleware.After)
503}
504
505func addOpGetOpenIdTokenForDeveloperIdentityValidationMiddleware(stack *middleware.Stack) error {
506	return stack.Initialize.Add(&validateOpGetOpenIdTokenForDeveloperIdentity{}, middleware.After)
507}
508
509func addOpGetOpenIdTokenValidationMiddleware(stack *middleware.Stack) error {
510	return stack.Initialize.Add(&validateOpGetOpenIdToken{}, middleware.After)
511}
512
513func addOpGetPrincipalTagAttributeMapValidationMiddleware(stack *middleware.Stack) error {
514	return stack.Initialize.Add(&validateOpGetPrincipalTagAttributeMap{}, middleware.After)
515}
516
517func addOpListIdentitiesValidationMiddleware(stack *middleware.Stack) error {
518	return stack.Initialize.Add(&validateOpListIdentities{}, middleware.After)
519}
520
521func addOpListIdentityPoolsValidationMiddleware(stack *middleware.Stack) error {
522	return stack.Initialize.Add(&validateOpListIdentityPools{}, middleware.After)
523}
524
525func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
526	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
527}
528
529func addOpLookupDeveloperIdentityValidationMiddleware(stack *middleware.Stack) error {
530	return stack.Initialize.Add(&validateOpLookupDeveloperIdentity{}, middleware.After)
531}
532
533func addOpMergeDeveloperIdentitiesValidationMiddleware(stack *middleware.Stack) error {
534	return stack.Initialize.Add(&validateOpMergeDeveloperIdentities{}, middleware.After)
535}
536
537func addOpSetIdentityPoolRolesValidationMiddleware(stack *middleware.Stack) error {
538	return stack.Initialize.Add(&validateOpSetIdentityPoolRoles{}, middleware.After)
539}
540
541func addOpSetPrincipalTagAttributeMapValidationMiddleware(stack *middleware.Stack) error {
542	return stack.Initialize.Add(&validateOpSetPrincipalTagAttributeMap{}, middleware.After)
543}
544
545func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
546	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
547}
548
549func addOpUnlinkDeveloperIdentityValidationMiddleware(stack *middleware.Stack) error {
550	return stack.Initialize.Add(&validateOpUnlinkDeveloperIdentity{}, middleware.After)
551}
552
553func addOpUnlinkIdentityValidationMiddleware(stack *middleware.Stack) error {
554	return stack.Initialize.Add(&validateOpUnlinkIdentity{}, middleware.After)
555}
556
557func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
558	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
559}
560
561func addOpUpdateIdentityPoolValidationMiddleware(stack *middleware.Stack) error {
562	return stack.Initialize.Add(&validateOpUpdateIdentityPool{}, middleware.After)
563}
564
565func validateMappingRule(v *types.MappingRule) error {
566	if v == nil {
567		return nil
568	}
569	invalidParams := smithy.InvalidParamsError{Context: "MappingRule"}
570	if v.Claim == nil {
571		invalidParams.Add(smithy.NewErrParamRequired("Claim"))
572	}
573	if len(v.MatchType) == 0 {
574		invalidParams.Add(smithy.NewErrParamRequired("MatchType"))
575	}
576	if v.Value == nil {
577		invalidParams.Add(smithy.NewErrParamRequired("Value"))
578	}
579	if v.RoleARN == nil {
580		invalidParams.Add(smithy.NewErrParamRequired("RoleARN"))
581	}
582	if invalidParams.Len() > 0 {
583		return invalidParams
584	} else {
585		return nil
586	}
587}
588
589func validateMappingRulesList(v []types.MappingRule) error {
590	if v == nil {
591		return nil
592	}
593	invalidParams := smithy.InvalidParamsError{Context: "MappingRulesList"}
594	for i := range v {
595		if err := validateMappingRule(&v[i]); err != nil {
596			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
597		}
598	}
599	if invalidParams.Len() > 0 {
600		return invalidParams
601	} else {
602		return nil
603	}
604}
605
606func validateRoleMapping(v *types.RoleMapping) error {
607	if v == nil {
608		return nil
609	}
610	invalidParams := smithy.InvalidParamsError{Context: "RoleMapping"}
611	if len(v.Type) == 0 {
612		invalidParams.Add(smithy.NewErrParamRequired("Type"))
613	}
614	if v.RulesConfiguration != nil {
615		if err := validateRulesConfigurationType(v.RulesConfiguration); err != nil {
616			invalidParams.AddNested("RulesConfiguration", err.(smithy.InvalidParamsError))
617		}
618	}
619	if invalidParams.Len() > 0 {
620		return invalidParams
621	} else {
622		return nil
623	}
624}
625
626func validateRoleMappingMap(v map[string]types.RoleMapping) error {
627	if v == nil {
628		return nil
629	}
630	invalidParams := smithy.InvalidParamsError{Context: "RoleMappingMap"}
631	for key := range v {
632		value := v[key]
633		if err := validateRoleMapping(&value); err != nil {
634			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
635		}
636	}
637	if invalidParams.Len() > 0 {
638		return invalidParams
639	} else {
640		return nil
641	}
642}
643
644func validateRulesConfigurationType(v *types.RulesConfigurationType) error {
645	if v == nil {
646		return nil
647	}
648	invalidParams := smithy.InvalidParamsError{Context: "RulesConfigurationType"}
649	if v.Rules == nil {
650		invalidParams.Add(smithy.NewErrParamRequired("Rules"))
651	} else if v.Rules != nil {
652		if err := validateMappingRulesList(v.Rules); err != nil {
653			invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError))
654		}
655	}
656	if invalidParams.Len() > 0 {
657		return invalidParams
658	} else {
659		return nil
660	}
661}
662
663func validateOpCreateIdentityPoolInput(v *CreateIdentityPoolInput) error {
664	if v == nil {
665		return nil
666	}
667	invalidParams := smithy.InvalidParamsError{Context: "CreateIdentityPoolInput"}
668	if v.IdentityPoolName == nil {
669		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolName"))
670	}
671	if invalidParams.Len() > 0 {
672		return invalidParams
673	} else {
674		return nil
675	}
676}
677
678func validateOpDeleteIdentitiesInput(v *DeleteIdentitiesInput) error {
679	if v == nil {
680		return nil
681	}
682	invalidParams := smithy.InvalidParamsError{Context: "DeleteIdentitiesInput"}
683	if v.IdentityIdsToDelete == nil {
684		invalidParams.Add(smithy.NewErrParamRequired("IdentityIdsToDelete"))
685	}
686	if invalidParams.Len() > 0 {
687		return invalidParams
688	} else {
689		return nil
690	}
691}
692
693func validateOpDeleteIdentityPoolInput(v *DeleteIdentityPoolInput) error {
694	if v == nil {
695		return nil
696	}
697	invalidParams := smithy.InvalidParamsError{Context: "DeleteIdentityPoolInput"}
698	if v.IdentityPoolId == nil {
699		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolId"))
700	}
701	if invalidParams.Len() > 0 {
702		return invalidParams
703	} else {
704		return nil
705	}
706}
707
708func validateOpDescribeIdentityInput(v *DescribeIdentityInput) error {
709	if v == nil {
710		return nil
711	}
712	invalidParams := smithy.InvalidParamsError{Context: "DescribeIdentityInput"}
713	if v.IdentityId == nil {
714		invalidParams.Add(smithy.NewErrParamRequired("IdentityId"))
715	}
716	if invalidParams.Len() > 0 {
717		return invalidParams
718	} else {
719		return nil
720	}
721}
722
723func validateOpDescribeIdentityPoolInput(v *DescribeIdentityPoolInput) error {
724	if v == nil {
725		return nil
726	}
727	invalidParams := smithy.InvalidParamsError{Context: "DescribeIdentityPoolInput"}
728	if v.IdentityPoolId == nil {
729		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolId"))
730	}
731	if invalidParams.Len() > 0 {
732		return invalidParams
733	} else {
734		return nil
735	}
736}
737
738func validateOpGetCredentialsForIdentityInput(v *GetCredentialsForIdentityInput) error {
739	if v == nil {
740		return nil
741	}
742	invalidParams := smithy.InvalidParamsError{Context: "GetCredentialsForIdentityInput"}
743	if v.IdentityId == nil {
744		invalidParams.Add(smithy.NewErrParamRequired("IdentityId"))
745	}
746	if invalidParams.Len() > 0 {
747		return invalidParams
748	} else {
749		return nil
750	}
751}
752
753func validateOpGetIdentityPoolRolesInput(v *GetIdentityPoolRolesInput) error {
754	if v == nil {
755		return nil
756	}
757	invalidParams := smithy.InvalidParamsError{Context: "GetIdentityPoolRolesInput"}
758	if v.IdentityPoolId == nil {
759		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolId"))
760	}
761	if invalidParams.Len() > 0 {
762		return invalidParams
763	} else {
764		return nil
765	}
766}
767
768func validateOpGetIdInput(v *GetIdInput) error {
769	if v == nil {
770		return nil
771	}
772	invalidParams := smithy.InvalidParamsError{Context: "GetIdInput"}
773	if v.IdentityPoolId == nil {
774		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolId"))
775	}
776	if invalidParams.Len() > 0 {
777		return invalidParams
778	} else {
779		return nil
780	}
781}
782
783func validateOpGetOpenIdTokenForDeveloperIdentityInput(v *GetOpenIdTokenForDeveloperIdentityInput) error {
784	if v == nil {
785		return nil
786	}
787	invalidParams := smithy.InvalidParamsError{Context: "GetOpenIdTokenForDeveloperIdentityInput"}
788	if v.IdentityPoolId == nil {
789		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolId"))
790	}
791	if v.Logins == nil {
792		invalidParams.Add(smithy.NewErrParamRequired("Logins"))
793	}
794	if invalidParams.Len() > 0 {
795		return invalidParams
796	} else {
797		return nil
798	}
799}
800
801func validateOpGetOpenIdTokenInput(v *GetOpenIdTokenInput) error {
802	if v == nil {
803		return nil
804	}
805	invalidParams := smithy.InvalidParamsError{Context: "GetOpenIdTokenInput"}
806	if v.IdentityId == nil {
807		invalidParams.Add(smithy.NewErrParamRequired("IdentityId"))
808	}
809	if invalidParams.Len() > 0 {
810		return invalidParams
811	} else {
812		return nil
813	}
814}
815
816func validateOpGetPrincipalTagAttributeMapInput(v *GetPrincipalTagAttributeMapInput) error {
817	if v == nil {
818		return nil
819	}
820	invalidParams := smithy.InvalidParamsError{Context: "GetPrincipalTagAttributeMapInput"}
821	if v.IdentityPoolId == nil {
822		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolId"))
823	}
824	if v.IdentityProviderName == nil {
825		invalidParams.Add(smithy.NewErrParamRequired("IdentityProviderName"))
826	}
827	if invalidParams.Len() > 0 {
828		return invalidParams
829	} else {
830		return nil
831	}
832}
833
834func validateOpListIdentitiesInput(v *ListIdentitiesInput) error {
835	if v == nil {
836		return nil
837	}
838	invalidParams := smithy.InvalidParamsError{Context: "ListIdentitiesInput"}
839	if v.IdentityPoolId == nil {
840		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolId"))
841	}
842	if invalidParams.Len() > 0 {
843		return invalidParams
844	} else {
845		return nil
846	}
847}
848
849func validateOpListIdentityPoolsInput(v *ListIdentityPoolsInput) error {
850	if v == nil {
851		return nil
852	}
853	invalidParams := smithy.InvalidParamsError{Context: "ListIdentityPoolsInput"}
854	if invalidParams.Len() > 0 {
855		return invalidParams
856	} else {
857		return nil
858	}
859}
860
861func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
862	if v == nil {
863		return nil
864	}
865	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
866	if v.ResourceArn == nil {
867		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
868	}
869	if invalidParams.Len() > 0 {
870		return invalidParams
871	} else {
872		return nil
873	}
874}
875
876func validateOpLookupDeveloperIdentityInput(v *LookupDeveloperIdentityInput) error {
877	if v == nil {
878		return nil
879	}
880	invalidParams := smithy.InvalidParamsError{Context: "LookupDeveloperIdentityInput"}
881	if v.IdentityPoolId == nil {
882		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolId"))
883	}
884	if invalidParams.Len() > 0 {
885		return invalidParams
886	} else {
887		return nil
888	}
889}
890
891func validateOpMergeDeveloperIdentitiesInput(v *MergeDeveloperIdentitiesInput) error {
892	if v == nil {
893		return nil
894	}
895	invalidParams := smithy.InvalidParamsError{Context: "MergeDeveloperIdentitiesInput"}
896	if v.SourceUserIdentifier == nil {
897		invalidParams.Add(smithy.NewErrParamRequired("SourceUserIdentifier"))
898	}
899	if v.DestinationUserIdentifier == nil {
900		invalidParams.Add(smithy.NewErrParamRequired("DestinationUserIdentifier"))
901	}
902	if v.DeveloperProviderName == nil {
903		invalidParams.Add(smithy.NewErrParamRequired("DeveloperProviderName"))
904	}
905	if v.IdentityPoolId == nil {
906		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolId"))
907	}
908	if invalidParams.Len() > 0 {
909		return invalidParams
910	} else {
911		return nil
912	}
913}
914
915func validateOpSetIdentityPoolRolesInput(v *SetIdentityPoolRolesInput) error {
916	if v == nil {
917		return nil
918	}
919	invalidParams := smithy.InvalidParamsError{Context: "SetIdentityPoolRolesInput"}
920	if v.IdentityPoolId == nil {
921		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolId"))
922	}
923	if v.Roles == nil {
924		invalidParams.Add(smithy.NewErrParamRequired("Roles"))
925	}
926	if v.RoleMappings != nil {
927		if err := validateRoleMappingMap(v.RoleMappings); err != nil {
928			invalidParams.AddNested("RoleMappings", err.(smithy.InvalidParamsError))
929		}
930	}
931	if invalidParams.Len() > 0 {
932		return invalidParams
933	} else {
934		return nil
935	}
936}
937
938func validateOpSetPrincipalTagAttributeMapInput(v *SetPrincipalTagAttributeMapInput) error {
939	if v == nil {
940		return nil
941	}
942	invalidParams := smithy.InvalidParamsError{Context: "SetPrincipalTagAttributeMapInput"}
943	if v.IdentityPoolId == nil {
944		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolId"))
945	}
946	if v.IdentityProviderName == nil {
947		invalidParams.Add(smithy.NewErrParamRequired("IdentityProviderName"))
948	}
949	if invalidParams.Len() > 0 {
950		return invalidParams
951	} else {
952		return nil
953	}
954}
955
956func validateOpTagResourceInput(v *TagResourceInput) error {
957	if v == nil {
958		return nil
959	}
960	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
961	if v.ResourceArn == nil {
962		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
963	}
964	if v.Tags == nil {
965		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
966	}
967	if invalidParams.Len() > 0 {
968		return invalidParams
969	} else {
970		return nil
971	}
972}
973
974func validateOpUnlinkDeveloperIdentityInput(v *UnlinkDeveloperIdentityInput) error {
975	if v == nil {
976		return nil
977	}
978	invalidParams := smithy.InvalidParamsError{Context: "UnlinkDeveloperIdentityInput"}
979	if v.IdentityId == nil {
980		invalidParams.Add(smithy.NewErrParamRequired("IdentityId"))
981	}
982	if v.IdentityPoolId == nil {
983		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolId"))
984	}
985	if v.DeveloperProviderName == nil {
986		invalidParams.Add(smithy.NewErrParamRequired("DeveloperProviderName"))
987	}
988	if v.DeveloperUserIdentifier == nil {
989		invalidParams.Add(smithy.NewErrParamRequired("DeveloperUserIdentifier"))
990	}
991	if invalidParams.Len() > 0 {
992		return invalidParams
993	} else {
994		return nil
995	}
996}
997
998func validateOpUnlinkIdentityInput(v *UnlinkIdentityInput) error {
999	if v == nil {
1000		return nil
1001	}
1002	invalidParams := smithy.InvalidParamsError{Context: "UnlinkIdentityInput"}
1003	if v.IdentityId == nil {
1004		invalidParams.Add(smithy.NewErrParamRequired("IdentityId"))
1005	}
1006	if v.Logins == nil {
1007		invalidParams.Add(smithy.NewErrParamRequired("Logins"))
1008	}
1009	if v.LoginsToRemove == nil {
1010		invalidParams.Add(smithy.NewErrParamRequired("LoginsToRemove"))
1011	}
1012	if invalidParams.Len() > 0 {
1013		return invalidParams
1014	} else {
1015		return nil
1016	}
1017}
1018
1019func validateOpUntagResourceInput(v *UntagResourceInput) error {
1020	if v == nil {
1021		return nil
1022	}
1023	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
1024	if v.ResourceArn == nil {
1025		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1026	}
1027	if v.TagKeys == nil {
1028		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1029	}
1030	if invalidParams.Len() > 0 {
1031		return invalidParams
1032	} else {
1033		return nil
1034	}
1035}
1036
1037func validateOpUpdateIdentityPoolInput(v *UpdateIdentityPoolInput) error {
1038	if v == nil {
1039		return nil
1040	}
1041	invalidParams := smithy.InvalidParamsError{Context: "UpdateIdentityPoolInput"}
1042	if v.IdentityPoolId == nil {
1043		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolId"))
1044	}
1045	if v.IdentityPoolName == nil {
1046		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolName"))
1047	}
1048	if invalidParams.Len() > 0 {
1049		return invalidParams
1050	} else {
1051		return nil
1052	}
1053}
1054