1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package cognitoidentityprovider
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/cognitoidentityprovider/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAddCustomAttributes struct {
14}
15
16func (*validateOpAddCustomAttributes) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAddCustomAttributes) 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.(*AddCustomAttributesInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAddCustomAttributesInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpAdminAddUserToGroup struct {
34}
35
36func (*validateOpAdminAddUserToGroup) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpAdminAddUserToGroup) 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.(*AdminAddUserToGroupInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpAdminAddUserToGroupInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpAdminConfirmSignUp struct {
54}
55
56func (*validateOpAdminConfirmSignUp) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpAdminConfirmSignUp) 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.(*AdminConfirmSignUpInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpAdminConfirmSignUpInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpAdminCreateUser struct {
74}
75
76func (*validateOpAdminCreateUser) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpAdminCreateUser) 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.(*AdminCreateUserInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpAdminCreateUserInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpAdminDeleteUserAttributes struct {
94}
95
96func (*validateOpAdminDeleteUserAttributes) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpAdminDeleteUserAttributes) 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.(*AdminDeleteUserAttributesInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpAdminDeleteUserAttributesInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpAdminDeleteUser struct {
114}
115
116func (*validateOpAdminDeleteUser) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpAdminDeleteUser) 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.(*AdminDeleteUserInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpAdminDeleteUserInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpAdminDisableProviderForUser struct {
134}
135
136func (*validateOpAdminDisableProviderForUser) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpAdminDisableProviderForUser) 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.(*AdminDisableProviderForUserInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpAdminDisableProviderForUserInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpAdminDisableUser struct {
154}
155
156func (*validateOpAdminDisableUser) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpAdminDisableUser) 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.(*AdminDisableUserInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpAdminDisableUserInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpAdminEnableUser struct {
174}
175
176func (*validateOpAdminEnableUser) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpAdminEnableUser) 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.(*AdminEnableUserInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpAdminEnableUserInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpAdminForgetDevice struct {
194}
195
196func (*validateOpAdminForgetDevice) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpAdminForgetDevice) 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.(*AdminForgetDeviceInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpAdminForgetDeviceInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpAdminGetDevice struct {
214}
215
216func (*validateOpAdminGetDevice) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpAdminGetDevice) 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.(*AdminGetDeviceInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpAdminGetDeviceInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpAdminGetUser struct {
234}
235
236func (*validateOpAdminGetUser) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpAdminGetUser) 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.(*AdminGetUserInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpAdminGetUserInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpAdminInitiateAuth struct {
254}
255
256func (*validateOpAdminInitiateAuth) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpAdminInitiateAuth) 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.(*AdminInitiateAuthInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpAdminInitiateAuthInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpAdminLinkProviderForUser struct {
274}
275
276func (*validateOpAdminLinkProviderForUser) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpAdminLinkProviderForUser) 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.(*AdminLinkProviderForUserInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpAdminLinkProviderForUserInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpAdminListDevices struct {
294}
295
296func (*validateOpAdminListDevices) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpAdminListDevices) 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.(*AdminListDevicesInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpAdminListDevicesInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpAdminListGroupsForUser struct {
314}
315
316func (*validateOpAdminListGroupsForUser) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpAdminListGroupsForUser) 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.(*AdminListGroupsForUserInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpAdminListGroupsForUserInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpAdminListUserAuthEvents struct {
334}
335
336func (*validateOpAdminListUserAuthEvents) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpAdminListUserAuthEvents) 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.(*AdminListUserAuthEventsInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpAdminListUserAuthEventsInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpAdminRemoveUserFromGroup struct {
354}
355
356func (*validateOpAdminRemoveUserFromGroup) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpAdminRemoveUserFromGroup) 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.(*AdminRemoveUserFromGroupInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpAdminRemoveUserFromGroupInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpAdminResetUserPassword struct {
374}
375
376func (*validateOpAdminResetUserPassword) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpAdminResetUserPassword) 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.(*AdminResetUserPasswordInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpAdminResetUserPasswordInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpAdminRespondToAuthChallenge struct {
394}
395
396func (*validateOpAdminRespondToAuthChallenge) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpAdminRespondToAuthChallenge) 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.(*AdminRespondToAuthChallengeInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpAdminRespondToAuthChallengeInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpAdminSetUserMFAPreference struct {
414}
415
416func (*validateOpAdminSetUserMFAPreference) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpAdminSetUserMFAPreference) 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.(*AdminSetUserMFAPreferenceInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpAdminSetUserMFAPreferenceInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpAdminSetUserPassword struct {
434}
435
436func (*validateOpAdminSetUserPassword) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpAdminSetUserPassword) 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.(*AdminSetUserPasswordInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpAdminSetUserPasswordInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpAdminSetUserSettings struct {
454}
455
456func (*validateOpAdminSetUserSettings) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpAdminSetUserSettings) 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.(*AdminSetUserSettingsInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpAdminSetUserSettingsInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpAdminUpdateAuthEventFeedback struct {
474}
475
476func (*validateOpAdminUpdateAuthEventFeedback) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpAdminUpdateAuthEventFeedback) 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.(*AdminUpdateAuthEventFeedbackInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpAdminUpdateAuthEventFeedbackInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpAdminUpdateDeviceStatus struct {
494}
495
496func (*validateOpAdminUpdateDeviceStatus) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpAdminUpdateDeviceStatus) 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.(*AdminUpdateDeviceStatusInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpAdminUpdateDeviceStatusInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpAdminUpdateUserAttributes struct {
514}
515
516func (*validateOpAdminUpdateUserAttributes) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpAdminUpdateUserAttributes) 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.(*AdminUpdateUserAttributesInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpAdminUpdateUserAttributesInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpAdminUserGlobalSignOut struct {
534}
535
536func (*validateOpAdminUserGlobalSignOut) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpAdminUserGlobalSignOut) 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.(*AdminUserGlobalSignOutInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpAdminUserGlobalSignOutInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpChangePassword struct {
554}
555
556func (*validateOpChangePassword) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpChangePassword) 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.(*ChangePasswordInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpChangePasswordInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpConfirmDevice struct {
574}
575
576func (*validateOpConfirmDevice) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpConfirmDevice) 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.(*ConfirmDeviceInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpConfirmDeviceInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpConfirmForgotPassword struct {
594}
595
596func (*validateOpConfirmForgotPassword) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpConfirmForgotPassword) 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.(*ConfirmForgotPasswordInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpConfirmForgotPasswordInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpConfirmSignUp struct {
614}
615
616func (*validateOpConfirmSignUp) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpConfirmSignUp) 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.(*ConfirmSignUpInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpConfirmSignUpInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpCreateGroup struct {
634}
635
636func (*validateOpCreateGroup) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpCreateGroup) 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.(*CreateGroupInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpCreateGroupInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpCreateIdentityProvider struct {
654}
655
656func (*validateOpCreateIdentityProvider) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpCreateIdentityProvider) 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.(*CreateIdentityProviderInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpCreateIdentityProviderInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpCreateResourceServer struct {
674}
675
676func (*validateOpCreateResourceServer) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpCreateResourceServer) 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.(*CreateResourceServerInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpCreateResourceServerInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpCreateUserImportJob struct {
694}
695
696func (*validateOpCreateUserImportJob) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpCreateUserImportJob) 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.(*CreateUserImportJobInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpCreateUserImportJobInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpCreateUserPoolClient struct {
714}
715
716func (*validateOpCreateUserPoolClient) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpCreateUserPoolClient) 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.(*CreateUserPoolClientInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpCreateUserPoolClientInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpCreateUserPoolDomain struct {
734}
735
736func (*validateOpCreateUserPoolDomain) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpCreateUserPoolDomain) 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.(*CreateUserPoolDomainInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpCreateUserPoolDomainInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpCreateUserPool struct {
754}
755
756func (*validateOpCreateUserPool) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpCreateUserPool) 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.(*CreateUserPoolInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpCreateUserPoolInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpDeleteGroup struct {
774}
775
776func (*validateOpDeleteGroup) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpDeleteGroup) 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.(*DeleteGroupInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpDeleteGroupInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpDeleteIdentityProvider struct {
794}
795
796func (*validateOpDeleteIdentityProvider) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpDeleteIdentityProvider) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
801	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
802) {
803	input, ok := in.Parameters.(*DeleteIdentityProviderInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpDeleteIdentityProviderInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpDeleteResourceServer struct {
814}
815
816func (*validateOpDeleteResourceServer) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpDeleteResourceServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
821	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
822) {
823	input, ok := in.Parameters.(*DeleteResourceServerInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpDeleteResourceServerInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpDeleteUserAttributes struct {
834}
835
836func (*validateOpDeleteUserAttributes) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpDeleteUserAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
841	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
842) {
843	input, ok := in.Parameters.(*DeleteUserAttributesInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpDeleteUserAttributesInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpDeleteUser struct {
854}
855
856func (*validateOpDeleteUser) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpDeleteUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
861	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
862) {
863	input, ok := in.Parameters.(*DeleteUserInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpDeleteUserInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpDeleteUserPoolClient struct {
874}
875
876func (*validateOpDeleteUserPoolClient) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpDeleteUserPoolClient) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
881	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
882) {
883	input, ok := in.Parameters.(*DeleteUserPoolClientInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpDeleteUserPoolClientInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893type validateOpDeleteUserPoolDomain struct {
894}
895
896func (*validateOpDeleteUserPoolDomain) ID() string {
897	return "OperationInputValidation"
898}
899
900func (m *validateOpDeleteUserPoolDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
901	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
902) {
903	input, ok := in.Parameters.(*DeleteUserPoolDomainInput)
904	if !ok {
905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
906	}
907	if err := validateOpDeleteUserPoolDomainInput(input); err != nil {
908		return out, metadata, err
909	}
910	return next.HandleInitialize(ctx, in)
911}
912
913type validateOpDeleteUserPool struct {
914}
915
916func (*validateOpDeleteUserPool) ID() string {
917	return "OperationInputValidation"
918}
919
920func (m *validateOpDeleteUserPool) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
921	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
922) {
923	input, ok := in.Parameters.(*DeleteUserPoolInput)
924	if !ok {
925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
926	}
927	if err := validateOpDeleteUserPoolInput(input); err != nil {
928		return out, metadata, err
929	}
930	return next.HandleInitialize(ctx, in)
931}
932
933type validateOpDescribeIdentityProvider struct {
934}
935
936func (*validateOpDescribeIdentityProvider) ID() string {
937	return "OperationInputValidation"
938}
939
940func (m *validateOpDescribeIdentityProvider) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
941	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
942) {
943	input, ok := in.Parameters.(*DescribeIdentityProviderInput)
944	if !ok {
945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
946	}
947	if err := validateOpDescribeIdentityProviderInput(input); err != nil {
948		return out, metadata, err
949	}
950	return next.HandleInitialize(ctx, in)
951}
952
953type validateOpDescribeResourceServer struct {
954}
955
956func (*validateOpDescribeResourceServer) ID() string {
957	return "OperationInputValidation"
958}
959
960func (m *validateOpDescribeResourceServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
961	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
962) {
963	input, ok := in.Parameters.(*DescribeResourceServerInput)
964	if !ok {
965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
966	}
967	if err := validateOpDescribeResourceServerInput(input); err != nil {
968		return out, metadata, err
969	}
970	return next.HandleInitialize(ctx, in)
971}
972
973type validateOpDescribeRiskConfiguration struct {
974}
975
976func (*validateOpDescribeRiskConfiguration) ID() string {
977	return "OperationInputValidation"
978}
979
980func (m *validateOpDescribeRiskConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
981	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
982) {
983	input, ok := in.Parameters.(*DescribeRiskConfigurationInput)
984	if !ok {
985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
986	}
987	if err := validateOpDescribeRiskConfigurationInput(input); err != nil {
988		return out, metadata, err
989	}
990	return next.HandleInitialize(ctx, in)
991}
992
993type validateOpDescribeUserImportJob struct {
994}
995
996func (*validateOpDescribeUserImportJob) ID() string {
997	return "OperationInputValidation"
998}
999
1000func (m *validateOpDescribeUserImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1001	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1002) {
1003	input, ok := in.Parameters.(*DescribeUserImportJobInput)
1004	if !ok {
1005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1006	}
1007	if err := validateOpDescribeUserImportJobInput(input); err != nil {
1008		return out, metadata, err
1009	}
1010	return next.HandleInitialize(ctx, in)
1011}
1012
1013type validateOpDescribeUserPoolClient struct {
1014}
1015
1016func (*validateOpDescribeUserPoolClient) ID() string {
1017	return "OperationInputValidation"
1018}
1019
1020func (m *validateOpDescribeUserPoolClient) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1021	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1022) {
1023	input, ok := in.Parameters.(*DescribeUserPoolClientInput)
1024	if !ok {
1025		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1026	}
1027	if err := validateOpDescribeUserPoolClientInput(input); err != nil {
1028		return out, metadata, err
1029	}
1030	return next.HandleInitialize(ctx, in)
1031}
1032
1033type validateOpDescribeUserPoolDomain struct {
1034}
1035
1036func (*validateOpDescribeUserPoolDomain) ID() string {
1037	return "OperationInputValidation"
1038}
1039
1040func (m *validateOpDescribeUserPoolDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1041	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1042) {
1043	input, ok := in.Parameters.(*DescribeUserPoolDomainInput)
1044	if !ok {
1045		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1046	}
1047	if err := validateOpDescribeUserPoolDomainInput(input); err != nil {
1048		return out, metadata, err
1049	}
1050	return next.HandleInitialize(ctx, in)
1051}
1052
1053type validateOpDescribeUserPool struct {
1054}
1055
1056func (*validateOpDescribeUserPool) ID() string {
1057	return "OperationInputValidation"
1058}
1059
1060func (m *validateOpDescribeUserPool) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1061	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1062) {
1063	input, ok := in.Parameters.(*DescribeUserPoolInput)
1064	if !ok {
1065		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1066	}
1067	if err := validateOpDescribeUserPoolInput(input); err != nil {
1068		return out, metadata, err
1069	}
1070	return next.HandleInitialize(ctx, in)
1071}
1072
1073type validateOpForgetDevice struct {
1074}
1075
1076func (*validateOpForgetDevice) ID() string {
1077	return "OperationInputValidation"
1078}
1079
1080func (m *validateOpForgetDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1081	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1082) {
1083	input, ok := in.Parameters.(*ForgetDeviceInput)
1084	if !ok {
1085		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1086	}
1087	if err := validateOpForgetDeviceInput(input); err != nil {
1088		return out, metadata, err
1089	}
1090	return next.HandleInitialize(ctx, in)
1091}
1092
1093type validateOpForgotPassword struct {
1094}
1095
1096func (*validateOpForgotPassword) ID() string {
1097	return "OperationInputValidation"
1098}
1099
1100func (m *validateOpForgotPassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1102) {
1103	input, ok := in.Parameters.(*ForgotPasswordInput)
1104	if !ok {
1105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1106	}
1107	if err := validateOpForgotPasswordInput(input); err != nil {
1108		return out, metadata, err
1109	}
1110	return next.HandleInitialize(ctx, in)
1111}
1112
1113type validateOpGetCSVHeader struct {
1114}
1115
1116func (*validateOpGetCSVHeader) ID() string {
1117	return "OperationInputValidation"
1118}
1119
1120func (m *validateOpGetCSVHeader) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1122) {
1123	input, ok := in.Parameters.(*GetCSVHeaderInput)
1124	if !ok {
1125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1126	}
1127	if err := validateOpGetCSVHeaderInput(input); err != nil {
1128		return out, metadata, err
1129	}
1130	return next.HandleInitialize(ctx, in)
1131}
1132
1133type validateOpGetDevice struct {
1134}
1135
1136func (*validateOpGetDevice) ID() string {
1137	return "OperationInputValidation"
1138}
1139
1140func (m *validateOpGetDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1142) {
1143	input, ok := in.Parameters.(*GetDeviceInput)
1144	if !ok {
1145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1146	}
1147	if err := validateOpGetDeviceInput(input); err != nil {
1148		return out, metadata, err
1149	}
1150	return next.HandleInitialize(ctx, in)
1151}
1152
1153type validateOpGetGroup struct {
1154}
1155
1156func (*validateOpGetGroup) ID() string {
1157	return "OperationInputValidation"
1158}
1159
1160func (m *validateOpGetGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1161	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1162) {
1163	input, ok := in.Parameters.(*GetGroupInput)
1164	if !ok {
1165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1166	}
1167	if err := validateOpGetGroupInput(input); err != nil {
1168		return out, metadata, err
1169	}
1170	return next.HandleInitialize(ctx, in)
1171}
1172
1173type validateOpGetIdentityProviderByIdentifier struct {
1174}
1175
1176func (*validateOpGetIdentityProviderByIdentifier) ID() string {
1177	return "OperationInputValidation"
1178}
1179
1180func (m *validateOpGetIdentityProviderByIdentifier) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1181	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1182) {
1183	input, ok := in.Parameters.(*GetIdentityProviderByIdentifierInput)
1184	if !ok {
1185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1186	}
1187	if err := validateOpGetIdentityProviderByIdentifierInput(input); err != nil {
1188		return out, metadata, err
1189	}
1190	return next.HandleInitialize(ctx, in)
1191}
1192
1193type validateOpGetSigningCertificate struct {
1194}
1195
1196func (*validateOpGetSigningCertificate) ID() string {
1197	return "OperationInputValidation"
1198}
1199
1200func (m *validateOpGetSigningCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1201	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1202) {
1203	input, ok := in.Parameters.(*GetSigningCertificateInput)
1204	if !ok {
1205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1206	}
1207	if err := validateOpGetSigningCertificateInput(input); err != nil {
1208		return out, metadata, err
1209	}
1210	return next.HandleInitialize(ctx, in)
1211}
1212
1213type validateOpGetUICustomization struct {
1214}
1215
1216func (*validateOpGetUICustomization) ID() string {
1217	return "OperationInputValidation"
1218}
1219
1220func (m *validateOpGetUICustomization) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1221	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1222) {
1223	input, ok := in.Parameters.(*GetUICustomizationInput)
1224	if !ok {
1225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1226	}
1227	if err := validateOpGetUICustomizationInput(input); err != nil {
1228		return out, metadata, err
1229	}
1230	return next.HandleInitialize(ctx, in)
1231}
1232
1233type validateOpGetUserAttributeVerificationCode struct {
1234}
1235
1236func (*validateOpGetUserAttributeVerificationCode) ID() string {
1237	return "OperationInputValidation"
1238}
1239
1240func (m *validateOpGetUserAttributeVerificationCode) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1241	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1242) {
1243	input, ok := in.Parameters.(*GetUserAttributeVerificationCodeInput)
1244	if !ok {
1245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1246	}
1247	if err := validateOpGetUserAttributeVerificationCodeInput(input); err != nil {
1248		return out, metadata, err
1249	}
1250	return next.HandleInitialize(ctx, in)
1251}
1252
1253type validateOpGetUser struct {
1254}
1255
1256func (*validateOpGetUser) ID() string {
1257	return "OperationInputValidation"
1258}
1259
1260func (m *validateOpGetUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1261	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1262) {
1263	input, ok := in.Parameters.(*GetUserInput)
1264	if !ok {
1265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1266	}
1267	if err := validateOpGetUserInput(input); err != nil {
1268		return out, metadata, err
1269	}
1270	return next.HandleInitialize(ctx, in)
1271}
1272
1273type validateOpGetUserPoolMfaConfig struct {
1274}
1275
1276func (*validateOpGetUserPoolMfaConfig) ID() string {
1277	return "OperationInputValidation"
1278}
1279
1280func (m *validateOpGetUserPoolMfaConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1281	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1282) {
1283	input, ok := in.Parameters.(*GetUserPoolMfaConfigInput)
1284	if !ok {
1285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1286	}
1287	if err := validateOpGetUserPoolMfaConfigInput(input); err != nil {
1288		return out, metadata, err
1289	}
1290	return next.HandleInitialize(ctx, in)
1291}
1292
1293type validateOpGlobalSignOut struct {
1294}
1295
1296func (*validateOpGlobalSignOut) ID() string {
1297	return "OperationInputValidation"
1298}
1299
1300func (m *validateOpGlobalSignOut) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1301	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1302) {
1303	input, ok := in.Parameters.(*GlobalSignOutInput)
1304	if !ok {
1305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1306	}
1307	if err := validateOpGlobalSignOutInput(input); err != nil {
1308		return out, metadata, err
1309	}
1310	return next.HandleInitialize(ctx, in)
1311}
1312
1313type validateOpInitiateAuth struct {
1314}
1315
1316func (*validateOpInitiateAuth) ID() string {
1317	return "OperationInputValidation"
1318}
1319
1320func (m *validateOpInitiateAuth) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1321	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1322) {
1323	input, ok := in.Parameters.(*InitiateAuthInput)
1324	if !ok {
1325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1326	}
1327	if err := validateOpInitiateAuthInput(input); err != nil {
1328		return out, metadata, err
1329	}
1330	return next.HandleInitialize(ctx, in)
1331}
1332
1333type validateOpListDevices struct {
1334}
1335
1336func (*validateOpListDevices) ID() string {
1337	return "OperationInputValidation"
1338}
1339
1340func (m *validateOpListDevices) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1341	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1342) {
1343	input, ok := in.Parameters.(*ListDevicesInput)
1344	if !ok {
1345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1346	}
1347	if err := validateOpListDevicesInput(input); err != nil {
1348		return out, metadata, err
1349	}
1350	return next.HandleInitialize(ctx, in)
1351}
1352
1353type validateOpListGroups struct {
1354}
1355
1356func (*validateOpListGroups) ID() string {
1357	return "OperationInputValidation"
1358}
1359
1360func (m *validateOpListGroups) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1361	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1362) {
1363	input, ok := in.Parameters.(*ListGroupsInput)
1364	if !ok {
1365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1366	}
1367	if err := validateOpListGroupsInput(input); err != nil {
1368		return out, metadata, err
1369	}
1370	return next.HandleInitialize(ctx, in)
1371}
1372
1373type validateOpListIdentityProviders struct {
1374}
1375
1376func (*validateOpListIdentityProviders) ID() string {
1377	return "OperationInputValidation"
1378}
1379
1380func (m *validateOpListIdentityProviders) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1381	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1382) {
1383	input, ok := in.Parameters.(*ListIdentityProvidersInput)
1384	if !ok {
1385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1386	}
1387	if err := validateOpListIdentityProvidersInput(input); err != nil {
1388		return out, metadata, err
1389	}
1390	return next.HandleInitialize(ctx, in)
1391}
1392
1393type validateOpListResourceServers struct {
1394}
1395
1396func (*validateOpListResourceServers) ID() string {
1397	return "OperationInputValidation"
1398}
1399
1400func (m *validateOpListResourceServers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1401	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1402) {
1403	input, ok := in.Parameters.(*ListResourceServersInput)
1404	if !ok {
1405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1406	}
1407	if err := validateOpListResourceServersInput(input); err != nil {
1408		return out, metadata, err
1409	}
1410	return next.HandleInitialize(ctx, in)
1411}
1412
1413type validateOpListTagsForResource struct {
1414}
1415
1416func (*validateOpListTagsForResource) ID() string {
1417	return "OperationInputValidation"
1418}
1419
1420func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1421	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1422) {
1423	input, ok := in.Parameters.(*ListTagsForResourceInput)
1424	if !ok {
1425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1426	}
1427	if err := validateOpListTagsForResourceInput(input); err != nil {
1428		return out, metadata, err
1429	}
1430	return next.HandleInitialize(ctx, in)
1431}
1432
1433type validateOpListUserImportJobs struct {
1434}
1435
1436func (*validateOpListUserImportJobs) ID() string {
1437	return "OperationInputValidation"
1438}
1439
1440func (m *validateOpListUserImportJobs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1441	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1442) {
1443	input, ok := in.Parameters.(*ListUserImportJobsInput)
1444	if !ok {
1445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1446	}
1447	if err := validateOpListUserImportJobsInput(input); err != nil {
1448		return out, metadata, err
1449	}
1450	return next.HandleInitialize(ctx, in)
1451}
1452
1453type validateOpListUserPoolClients struct {
1454}
1455
1456func (*validateOpListUserPoolClients) ID() string {
1457	return "OperationInputValidation"
1458}
1459
1460func (m *validateOpListUserPoolClients) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1461	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1462) {
1463	input, ok := in.Parameters.(*ListUserPoolClientsInput)
1464	if !ok {
1465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1466	}
1467	if err := validateOpListUserPoolClientsInput(input); err != nil {
1468		return out, metadata, err
1469	}
1470	return next.HandleInitialize(ctx, in)
1471}
1472
1473type validateOpListUserPools struct {
1474}
1475
1476func (*validateOpListUserPools) ID() string {
1477	return "OperationInputValidation"
1478}
1479
1480func (m *validateOpListUserPools) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1481	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1482) {
1483	input, ok := in.Parameters.(*ListUserPoolsInput)
1484	if !ok {
1485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1486	}
1487	if err := validateOpListUserPoolsInput(input); err != nil {
1488		return out, metadata, err
1489	}
1490	return next.HandleInitialize(ctx, in)
1491}
1492
1493type validateOpListUsersInGroup struct {
1494}
1495
1496func (*validateOpListUsersInGroup) ID() string {
1497	return "OperationInputValidation"
1498}
1499
1500func (m *validateOpListUsersInGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1501	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1502) {
1503	input, ok := in.Parameters.(*ListUsersInGroupInput)
1504	if !ok {
1505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1506	}
1507	if err := validateOpListUsersInGroupInput(input); err != nil {
1508		return out, metadata, err
1509	}
1510	return next.HandleInitialize(ctx, in)
1511}
1512
1513type validateOpListUsers struct {
1514}
1515
1516func (*validateOpListUsers) ID() string {
1517	return "OperationInputValidation"
1518}
1519
1520func (m *validateOpListUsers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1521	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1522) {
1523	input, ok := in.Parameters.(*ListUsersInput)
1524	if !ok {
1525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1526	}
1527	if err := validateOpListUsersInput(input); err != nil {
1528		return out, metadata, err
1529	}
1530	return next.HandleInitialize(ctx, in)
1531}
1532
1533type validateOpResendConfirmationCode struct {
1534}
1535
1536func (*validateOpResendConfirmationCode) ID() string {
1537	return "OperationInputValidation"
1538}
1539
1540func (m *validateOpResendConfirmationCode) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1541	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1542) {
1543	input, ok := in.Parameters.(*ResendConfirmationCodeInput)
1544	if !ok {
1545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1546	}
1547	if err := validateOpResendConfirmationCodeInput(input); err != nil {
1548		return out, metadata, err
1549	}
1550	return next.HandleInitialize(ctx, in)
1551}
1552
1553type validateOpRespondToAuthChallenge struct {
1554}
1555
1556func (*validateOpRespondToAuthChallenge) ID() string {
1557	return "OperationInputValidation"
1558}
1559
1560func (m *validateOpRespondToAuthChallenge) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1561	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1562) {
1563	input, ok := in.Parameters.(*RespondToAuthChallengeInput)
1564	if !ok {
1565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1566	}
1567	if err := validateOpRespondToAuthChallengeInput(input); err != nil {
1568		return out, metadata, err
1569	}
1570	return next.HandleInitialize(ctx, in)
1571}
1572
1573type validateOpRevokeToken struct {
1574}
1575
1576func (*validateOpRevokeToken) ID() string {
1577	return "OperationInputValidation"
1578}
1579
1580func (m *validateOpRevokeToken) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1581	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1582) {
1583	input, ok := in.Parameters.(*RevokeTokenInput)
1584	if !ok {
1585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1586	}
1587	if err := validateOpRevokeTokenInput(input); err != nil {
1588		return out, metadata, err
1589	}
1590	return next.HandleInitialize(ctx, in)
1591}
1592
1593type validateOpSetRiskConfiguration struct {
1594}
1595
1596func (*validateOpSetRiskConfiguration) ID() string {
1597	return "OperationInputValidation"
1598}
1599
1600func (m *validateOpSetRiskConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1601	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1602) {
1603	input, ok := in.Parameters.(*SetRiskConfigurationInput)
1604	if !ok {
1605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1606	}
1607	if err := validateOpSetRiskConfigurationInput(input); err != nil {
1608		return out, metadata, err
1609	}
1610	return next.HandleInitialize(ctx, in)
1611}
1612
1613type validateOpSetUICustomization struct {
1614}
1615
1616func (*validateOpSetUICustomization) ID() string {
1617	return "OperationInputValidation"
1618}
1619
1620func (m *validateOpSetUICustomization) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1621	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1622) {
1623	input, ok := in.Parameters.(*SetUICustomizationInput)
1624	if !ok {
1625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1626	}
1627	if err := validateOpSetUICustomizationInput(input); err != nil {
1628		return out, metadata, err
1629	}
1630	return next.HandleInitialize(ctx, in)
1631}
1632
1633type validateOpSetUserMFAPreference struct {
1634}
1635
1636func (*validateOpSetUserMFAPreference) ID() string {
1637	return "OperationInputValidation"
1638}
1639
1640func (m *validateOpSetUserMFAPreference) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1641	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1642) {
1643	input, ok := in.Parameters.(*SetUserMFAPreferenceInput)
1644	if !ok {
1645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1646	}
1647	if err := validateOpSetUserMFAPreferenceInput(input); err != nil {
1648		return out, metadata, err
1649	}
1650	return next.HandleInitialize(ctx, in)
1651}
1652
1653type validateOpSetUserPoolMfaConfig struct {
1654}
1655
1656func (*validateOpSetUserPoolMfaConfig) ID() string {
1657	return "OperationInputValidation"
1658}
1659
1660func (m *validateOpSetUserPoolMfaConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1661	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1662) {
1663	input, ok := in.Parameters.(*SetUserPoolMfaConfigInput)
1664	if !ok {
1665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1666	}
1667	if err := validateOpSetUserPoolMfaConfigInput(input); err != nil {
1668		return out, metadata, err
1669	}
1670	return next.HandleInitialize(ctx, in)
1671}
1672
1673type validateOpSetUserSettings struct {
1674}
1675
1676func (*validateOpSetUserSettings) ID() string {
1677	return "OperationInputValidation"
1678}
1679
1680func (m *validateOpSetUserSettings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1681	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1682) {
1683	input, ok := in.Parameters.(*SetUserSettingsInput)
1684	if !ok {
1685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1686	}
1687	if err := validateOpSetUserSettingsInput(input); err != nil {
1688		return out, metadata, err
1689	}
1690	return next.HandleInitialize(ctx, in)
1691}
1692
1693type validateOpSignUp struct {
1694}
1695
1696func (*validateOpSignUp) ID() string {
1697	return "OperationInputValidation"
1698}
1699
1700func (m *validateOpSignUp) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1701	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1702) {
1703	input, ok := in.Parameters.(*SignUpInput)
1704	if !ok {
1705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1706	}
1707	if err := validateOpSignUpInput(input); err != nil {
1708		return out, metadata, err
1709	}
1710	return next.HandleInitialize(ctx, in)
1711}
1712
1713type validateOpStartUserImportJob struct {
1714}
1715
1716func (*validateOpStartUserImportJob) ID() string {
1717	return "OperationInputValidation"
1718}
1719
1720func (m *validateOpStartUserImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1721	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1722) {
1723	input, ok := in.Parameters.(*StartUserImportJobInput)
1724	if !ok {
1725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1726	}
1727	if err := validateOpStartUserImportJobInput(input); err != nil {
1728		return out, metadata, err
1729	}
1730	return next.HandleInitialize(ctx, in)
1731}
1732
1733type validateOpStopUserImportJob struct {
1734}
1735
1736func (*validateOpStopUserImportJob) ID() string {
1737	return "OperationInputValidation"
1738}
1739
1740func (m *validateOpStopUserImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1741	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1742) {
1743	input, ok := in.Parameters.(*StopUserImportJobInput)
1744	if !ok {
1745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1746	}
1747	if err := validateOpStopUserImportJobInput(input); err != nil {
1748		return out, metadata, err
1749	}
1750	return next.HandleInitialize(ctx, in)
1751}
1752
1753type validateOpTagResource struct {
1754}
1755
1756func (*validateOpTagResource) ID() string {
1757	return "OperationInputValidation"
1758}
1759
1760func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1761	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1762) {
1763	input, ok := in.Parameters.(*TagResourceInput)
1764	if !ok {
1765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1766	}
1767	if err := validateOpTagResourceInput(input); err != nil {
1768		return out, metadata, err
1769	}
1770	return next.HandleInitialize(ctx, in)
1771}
1772
1773type validateOpUntagResource struct {
1774}
1775
1776func (*validateOpUntagResource) ID() string {
1777	return "OperationInputValidation"
1778}
1779
1780func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1781	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1782) {
1783	input, ok := in.Parameters.(*UntagResourceInput)
1784	if !ok {
1785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1786	}
1787	if err := validateOpUntagResourceInput(input); err != nil {
1788		return out, metadata, err
1789	}
1790	return next.HandleInitialize(ctx, in)
1791}
1792
1793type validateOpUpdateAuthEventFeedback struct {
1794}
1795
1796func (*validateOpUpdateAuthEventFeedback) ID() string {
1797	return "OperationInputValidation"
1798}
1799
1800func (m *validateOpUpdateAuthEventFeedback) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1801	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1802) {
1803	input, ok := in.Parameters.(*UpdateAuthEventFeedbackInput)
1804	if !ok {
1805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1806	}
1807	if err := validateOpUpdateAuthEventFeedbackInput(input); err != nil {
1808		return out, metadata, err
1809	}
1810	return next.HandleInitialize(ctx, in)
1811}
1812
1813type validateOpUpdateDeviceStatus struct {
1814}
1815
1816func (*validateOpUpdateDeviceStatus) ID() string {
1817	return "OperationInputValidation"
1818}
1819
1820func (m *validateOpUpdateDeviceStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1821	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1822) {
1823	input, ok := in.Parameters.(*UpdateDeviceStatusInput)
1824	if !ok {
1825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1826	}
1827	if err := validateOpUpdateDeviceStatusInput(input); err != nil {
1828		return out, metadata, err
1829	}
1830	return next.HandleInitialize(ctx, in)
1831}
1832
1833type validateOpUpdateGroup struct {
1834}
1835
1836func (*validateOpUpdateGroup) ID() string {
1837	return "OperationInputValidation"
1838}
1839
1840func (m *validateOpUpdateGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1841	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1842) {
1843	input, ok := in.Parameters.(*UpdateGroupInput)
1844	if !ok {
1845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1846	}
1847	if err := validateOpUpdateGroupInput(input); err != nil {
1848		return out, metadata, err
1849	}
1850	return next.HandleInitialize(ctx, in)
1851}
1852
1853type validateOpUpdateIdentityProvider struct {
1854}
1855
1856func (*validateOpUpdateIdentityProvider) ID() string {
1857	return "OperationInputValidation"
1858}
1859
1860func (m *validateOpUpdateIdentityProvider) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1861	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1862) {
1863	input, ok := in.Parameters.(*UpdateIdentityProviderInput)
1864	if !ok {
1865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1866	}
1867	if err := validateOpUpdateIdentityProviderInput(input); err != nil {
1868		return out, metadata, err
1869	}
1870	return next.HandleInitialize(ctx, in)
1871}
1872
1873type validateOpUpdateResourceServer struct {
1874}
1875
1876func (*validateOpUpdateResourceServer) ID() string {
1877	return "OperationInputValidation"
1878}
1879
1880func (m *validateOpUpdateResourceServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1881	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1882) {
1883	input, ok := in.Parameters.(*UpdateResourceServerInput)
1884	if !ok {
1885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1886	}
1887	if err := validateOpUpdateResourceServerInput(input); err != nil {
1888		return out, metadata, err
1889	}
1890	return next.HandleInitialize(ctx, in)
1891}
1892
1893type validateOpUpdateUserAttributes struct {
1894}
1895
1896func (*validateOpUpdateUserAttributes) ID() string {
1897	return "OperationInputValidation"
1898}
1899
1900func (m *validateOpUpdateUserAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1901	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1902) {
1903	input, ok := in.Parameters.(*UpdateUserAttributesInput)
1904	if !ok {
1905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1906	}
1907	if err := validateOpUpdateUserAttributesInput(input); err != nil {
1908		return out, metadata, err
1909	}
1910	return next.HandleInitialize(ctx, in)
1911}
1912
1913type validateOpUpdateUserPoolClient struct {
1914}
1915
1916func (*validateOpUpdateUserPoolClient) ID() string {
1917	return "OperationInputValidation"
1918}
1919
1920func (m *validateOpUpdateUserPoolClient) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1921	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1922) {
1923	input, ok := in.Parameters.(*UpdateUserPoolClientInput)
1924	if !ok {
1925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1926	}
1927	if err := validateOpUpdateUserPoolClientInput(input); err != nil {
1928		return out, metadata, err
1929	}
1930	return next.HandleInitialize(ctx, in)
1931}
1932
1933type validateOpUpdateUserPoolDomain struct {
1934}
1935
1936func (*validateOpUpdateUserPoolDomain) ID() string {
1937	return "OperationInputValidation"
1938}
1939
1940func (m *validateOpUpdateUserPoolDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1941	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1942) {
1943	input, ok := in.Parameters.(*UpdateUserPoolDomainInput)
1944	if !ok {
1945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1946	}
1947	if err := validateOpUpdateUserPoolDomainInput(input); err != nil {
1948		return out, metadata, err
1949	}
1950	return next.HandleInitialize(ctx, in)
1951}
1952
1953type validateOpUpdateUserPool struct {
1954}
1955
1956func (*validateOpUpdateUserPool) ID() string {
1957	return "OperationInputValidation"
1958}
1959
1960func (m *validateOpUpdateUserPool) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1961	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1962) {
1963	input, ok := in.Parameters.(*UpdateUserPoolInput)
1964	if !ok {
1965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1966	}
1967	if err := validateOpUpdateUserPoolInput(input); err != nil {
1968		return out, metadata, err
1969	}
1970	return next.HandleInitialize(ctx, in)
1971}
1972
1973type validateOpVerifySoftwareToken struct {
1974}
1975
1976func (*validateOpVerifySoftwareToken) ID() string {
1977	return "OperationInputValidation"
1978}
1979
1980func (m *validateOpVerifySoftwareToken) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1981	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1982) {
1983	input, ok := in.Parameters.(*VerifySoftwareTokenInput)
1984	if !ok {
1985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1986	}
1987	if err := validateOpVerifySoftwareTokenInput(input); err != nil {
1988		return out, metadata, err
1989	}
1990	return next.HandleInitialize(ctx, in)
1991}
1992
1993type validateOpVerifyUserAttribute struct {
1994}
1995
1996func (*validateOpVerifyUserAttribute) ID() string {
1997	return "OperationInputValidation"
1998}
1999
2000func (m *validateOpVerifyUserAttribute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2001	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2002) {
2003	input, ok := in.Parameters.(*VerifyUserAttributeInput)
2004	if !ok {
2005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2006	}
2007	if err := validateOpVerifyUserAttributeInput(input); err != nil {
2008		return out, metadata, err
2009	}
2010	return next.HandleInitialize(ctx, in)
2011}
2012
2013func addOpAddCustomAttributesValidationMiddleware(stack *middleware.Stack) error {
2014	return stack.Initialize.Add(&validateOpAddCustomAttributes{}, middleware.After)
2015}
2016
2017func addOpAdminAddUserToGroupValidationMiddleware(stack *middleware.Stack) error {
2018	return stack.Initialize.Add(&validateOpAdminAddUserToGroup{}, middleware.After)
2019}
2020
2021func addOpAdminConfirmSignUpValidationMiddleware(stack *middleware.Stack) error {
2022	return stack.Initialize.Add(&validateOpAdminConfirmSignUp{}, middleware.After)
2023}
2024
2025func addOpAdminCreateUserValidationMiddleware(stack *middleware.Stack) error {
2026	return stack.Initialize.Add(&validateOpAdminCreateUser{}, middleware.After)
2027}
2028
2029func addOpAdminDeleteUserAttributesValidationMiddleware(stack *middleware.Stack) error {
2030	return stack.Initialize.Add(&validateOpAdminDeleteUserAttributes{}, middleware.After)
2031}
2032
2033func addOpAdminDeleteUserValidationMiddleware(stack *middleware.Stack) error {
2034	return stack.Initialize.Add(&validateOpAdminDeleteUser{}, middleware.After)
2035}
2036
2037func addOpAdminDisableProviderForUserValidationMiddleware(stack *middleware.Stack) error {
2038	return stack.Initialize.Add(&validateOpAdminDisableProviderForUser{}, middleware.After)
2039}
2040
2041func addOpAdminDisableUserValidationMiddleware(stack *middleware.Stack) error {
2042	return stack.Initialize.Add(&validateOpAdminDisableUser{}, middleware.After)
2043}
2044
2045func addOpAdminEnableUserValidationMiddleware(stack *middleware.Stack) error {
2046	return stack.Initialize.Add(&validateOpAdminEnableUser{}, middleware.After)
2047}
2048
2049func addOpAdminForgetDeviceValidationMiddleware(stack *middleware.Stack) error {
2050	return stack.Initialize.Add(&validateOpAdminForgetDevice{}, middleware.After)
2051}
2052
2053func addOpAdminGetDeviceValidationMiddleware(stack *middleware.Stack) error {
2054	return stack.Initialize.Add(&validateOpAdminGetDevice{}, middleware.After)
2055}
2056
2057func addOpAdminGetUserValidationMiddleware(stack *middleware.Stack) error {
2058	return stack.Initialize.Add(&validateOpAdminGetUser{}, middleware.After)
2059}
2060
2061func addOpAdminInitiateAuthValidationMiddleware(stack *middleware.Stack) error {
2062	return stack.Initialize.Add(&validateOpAdminInitiateAuth{}, middleware.After)
2063}
2064
2065func addOpAdminLinkProviderForUserValidationMiddleware(stack *middleware.Stack) error {
2066	return stack.Initialize.Add(&validateOpAdminLinkProviderForUser{}, middleware.After)
2067}
2068
2069func addOpAdminListDevicesValidationMiddleware(stack *middleware.Stack) error {
2070	return stack.Initialize.Add(&validateOpAdminListDevices{}, middleware.After)
2071}
2072
2073func addOpAdminListGroupsForUserValidationMiddleware(stack *middleware.Stack) error {
2074	return stack.Initialize.Add(&validateOpAdminListGroupsForUser{}, middleware.After)
2075}
2076
2077func addOpAdminListUserAuthEventsValidationMiddleware(stack *middleware.Stack) error {
2078	return stack.Initialize.Add(&validateOpAdminListUserAuthEvents{}, middleware.After)
2079}
2080
2081func addOpAdminRemoveUserFromGroupValidationMiddleware(stack *middleware.Stack) error {
2082	return stack.Initialize.Add(&validateOpAdminRemoveUserFromGroup{}, middleware.After)
2083}
2084
2085func addOpAdminResetUserPasswordValidationMiddleware(stack *middleware.Stack) error {
2086	return stack.Initialize.Add(&validateOpAdminResetUserPassword{}, middleware.After)
2087}
2088
2089func addOpAdminRespondToAuthChallengeValidationMiddleware(stack *middleware.Stack) error {
2090	return stack.Initialize.Add(&validateOpAdminRespondToAuthChallenge{}, middleware.After)
2091}
2092
2093func addOpAdminSetUserMFAPreferenceValidationMiddleware(stack *middleware.Stack) error {
2094	return stack.Initialize.Add(&validateOpAdminSetUserMFAPreference{}, middleware.After)
2095}
2096
2097func addOpAdminSetUserPasswordValidationMiddleware(stack *middleware.Stack) error {
2098	return stack.Initialize.Add(&validateOpAdminSetUserPassword{}, middleware.After)
2099}
2100
2101func addOpAdminSetUserSettingsValidationMiddleware(stack *middleware.Stack) error {
2102	return stack.Initialize.Add(&validateOpAdminSetUserSettings{}, middleware.After)
2103}
2104
2105func addOpAdminUpdateAuthEventFeedbackValidationMiddleware(stack *middleware.Stack) error {
2106	return stack.Initialize.Add(&validateOpAdminUpdateAuthEventFeedback{}, middleware.After)
2107}
2108
2109func addOpAdminUpdateDeviceStatusValidationMiddleware(stack *middleware.Stack) error {
2110	return stack.Initialize.Add(&validateOpAdminUpdateDeviceStatus{}, middleware.After)
2111}
2112
2113func addOpAdminUpdateUserAttributesValidationMiddleware(stack *middleware.Stack) error {
2114	return stack.Initialize.Add(&validateOpAdminUpdateUserAttributes{}, middleware.After)
2115}
2116
2117func addOpAdminUserGlobalSignOutValidationMiddleware(stack *middleware.Stack) error {
2118	return stack.Initialize.Add(&validateOpAdminUserGlobalSignOut{}, middleware.After)
2119}
2120
2121func addOpChangePasswordValidationMiddleware(stack *middleware.Stack) error {
2122	return stack.Initialize.Add(&validateOpChangePassword{}, middleware.After)
2123}
2124
2125func addOpConfirmDeviceValidationMiddleware(stack *middleware.Stack) error {
2126	return stack.Initialize.Add(&validateOpConfirmDevice{}, middleware.After)
2127}
2128
2129func addOpConfirmForgotPasswordValidationMiddleware(stack *middleware.Stack) error {
2130	return stack.Initialize.Add(&validateOpConfirmForgotPassword{}, middleware.After)
2131}
2132
2133func addOpConfirmSignUpValidationMiddleware(stack *middleware.Stack) error {
2134	return stack.Initialize.Add(&validateOpConfirmSignUp{}, middleware.After)
2135}
2136
2137func addOpCreateGroupValidationMiddleware(stack *middleware.Stack) error {
2138	return stack.Initialize.Add(&validateOpCreateGroup{}, middleware.After)
2139}
2140
2141func addOpCreateIdentityProviderValidationMiddleware(stack *middleware.Stack) error {
2142	return stack.Initialize.Add(&validateOpCreateIdentityProvider{}, middleware.After)
2143}
2144
2145func addOpCreateResourceServerValidationMiddleware(stack *middleware.Stack) error {
2146	return stack.Initialize.Add(&validateOpCreateResourceServer{}, middleware.After)
2147}
2148
2149func addOpCreateUserImportJobValidationMiddleware(stack *middleware.Stack) error {
2150	return stack.Initialize.Add(&validateOpCreateUserImportJob{}, middleware.After)
2151}
2152
2153func addOpCreateUserPoolClientValidationMiddleware(stack *middleware.Stack) error {
2154	return stack.Initialize.Add(&validateOpCreateUserPoolClient{}, middleware.After)
2155}
2156
2157func addOpCreateUserPoolDomainValidationMiddleware(stack *middleware.Stack) error {
2158	return stack.Initialize.Add(&validateOpCreateUserPoolDomain{}, middleware.After)
2159}
2160
2161func addOpCreateUserPoolValidationMiddleware(stack *middleware.Stack) error {
2162	return stack.Initialize.Add(&validateOpCreateUserPool{}, middleware.After)
2163}
2164
2165func addOpDeleteGroupValidationMiddleware(stack *middleware.Stack) error {
2166	return stack.Initialize.Add(&validateOpDeleteGroup{}, middleware.After)
2167}
2168
2169func addOpDeleteIdentityProviderValidationMiddleware(stack *middleware.Stack) error {
2170	return stack.Initialize.Add(&validateOpDeleteIdentityProvider{}, middleware.After)
2171}
2172
2173func addOpDeleteResourceServerValidationMiddleware(stack *middleware.Stack) error {
2174	return stack.Initialize.Add(&validateOpDeleteResourceServer{}, middleware.After)
2175}
2176
2177func addOpDeleteUserAttributesValidationMiddleware(stack *middleware.Stack) error {
2178	return stack.Initialize.Add(&validateOpDeleteUserAttributes{}, middleware.After)
2179}
2180
2181func addOpDeleteUserValidationMiddleware(stack *middleware.Stack) error {
2182	return stack.Initialize.Add(&validateOpDeleteUser{}, middleware.After)
2183}
2184
2185func addOpDeleteUserPoolClientValidationMiddleware(stack *middleware.Stack) error {
2186	return stack.Initialize.Add(&validateOpDeleteUserPoolClient{}, middleware.After)
2187}
2188
2189func addOpDeleteUserPoolDomainValidationMiddleware(stack *middleware.Stack) error {
2190	return stack.Initialize.Add(&validateOpDeleteUserPoolDomain{}, middleware.After)
2191}
2192
2193func addOpDeleteUserPoolValidationMiddleware(stack *middleware.Stack) error {
2194	return stack.Initialize.Add(&validateOpDeleteUserPool{}, middleware.After)
2195}
2196
2197func addOpDescribeIdentityProviderValidationMiddleware(stack *middleware.Stack) error {
2198	return stack.Initialize.Add(&validateOpDescribeIdentityProvider{}, middleware.After)
2199}
2200
2201func addOpDescribeResourceServerValidationMiddleware(stack *middleware.Stack) error {
2202	return stack.Initialize.Add(&validateOpDescribeResourceServer{}, middleware.After)
2203}
2204
2205func addOpDescribeRiskConfigurationValidationMiddleware(stack *middleware.Stack) error {
2206	return stack.Initialize.Add(&validateOpDescribeRiskConfiguration{}, middleware.After)
2207}
2208
2209func addOpDescribeUserImportJobValidationMiddleware(stack *middleware.Stack) error {
2210	return stack.Initialize.Add(&validateOpDescribeUserImportJob{}, middleware.After)
2211}
2212
2213func addOpDescribeUserPoolClientValidationMiddleware(stack *middleware.Stack) error {
2214	return stack.Initialize.Add(&validateOpDescribeUserPoolClient{}, middleware.After)
2215}
2216
2217func addOpDescribeUserPoolDomainValidationMiddleware(stack *middleware.Stack) error {
2218	return stack.Initialize.Add(&validateOpDescribeUserPoolDomain{}, middleware.After)
2219}
2220
2221func addOpDescribeUserPoolValidationMiddleware(stack *middleware.Stack) error {
2222	return stack.Initialize.Add(&validateOpDescribeUserPool{}, middleware.After)
2223}
2224
2225func addOpForgetDeviceValidationMiddleware(stack *middleware.Stack) error {
2226	return stack.Initialize.Add(&validateOpForgetDevice{}, middleware.After)
2227}
2228
2229func addOpForgotPasswordValidationMiddleware(stack *middleware.Stack) error {
2230	return stack.Initialize.Add(&validateOpForgotPassword{}, middleware.After)
2231}
2232
2233func addOpGetCSVHeaderValidationMiddleware(stack *middleware.Stack) error {
2234	return stack.Initialize.Add(&validateOpGetCSVHeader{}, middleware.After)
2235}
2236
2237func addOpGetDeviceValidationMiddleware(stack *middleware.Stack) error {
2238	return stack.Initialize.Add(&validateOpGetDevice{}, middleware.After)
2239}
2240
2241func addOpGetGroupValidationMiddleware(stack *middleware.Stack) error {
2242	return stack.Initialize.Add(&validateOpGetGroup{}, middleware.After)
2243}
2244
2245func addOpGetIdentityProviderByIdentifierValidationMiddleware(stack *middleware.Stack) error {
2246	return stack.Initialize.Add(&validateOpGetIdentityProviderByIdentifier{}, middleware.After)
2247}
2248
2249func addOpGetSigningCertificateValidationMiddleware(stack *middleware.Stack) error {
2250	return stack.Initialize.Add(&validateOpGetSigningCertificate{}, middleware.After)
2251}
2252
2253func addOpGetUICustomizationValidationMiddleware(stack *middleware.Stack) error {
2254	return stack.Initialize.Add(&validateOpGetUICustomization{}, middleware.After)
2255}
2256
2257func addOpGetUserAttributeVerificationCodeValidationMiddleware(stack *middleware.Stack) error {
2258	return stack.Initialize.Add(&validateOpGetUserAttributeVerificationCode{}, middleware.After)
2259}
2260
2261func addOpGetUserValidationMiddleware(stack *middleware.Stack) error {
2262	return stack.Initialize.Add(&validateOpGetUser{}, middleware.After)
2263}
2264
2265func addOpGetUserPoolMfaConfigValidationMiddleware(stack *middleware.Stack) error {
2266	return stack.Initialize.Add(&validateOpGetUserPoolMfaConfig{}, middleware.After)
2267}
2268
2269func addOpGlobalSignOutValidationMiddleware(stack *middleware.Stack) error {
2270	return stack.Initialize.Add(&validateOpGlobalSignOut{}, middleware.After)
2271}
2272
2273func addOpInitiateAuthValidationMiddleware(stack *middleware.Stack) error {
2274	return stack.Initialize.Add(&validateOpInitiateAuth{}, middleware.After)
2275}
2276
2277func addOpListDevicesValidationMiddleware(stack *middleware.Stack) error {
2278	return stack.Initialize.Add(&validateOpListDevices{}, middleware.After)
2279}
2280
2281func addOpListGroupsValidationMiddleware(stack *middleware.Stack) error {
2282	return stack.Initialize.Add(&validateOpListGroups{}, middleware.After)
2283}
2284
2285func addOpListIdentityProvidersValidationMiddleware(stack *middleware.Stack) error {
2286	return stack.Initialize.Add(&validateOpListIdentityProviders{}, middleware.After)
2287}
2288
2289func addOpListResourceServersValidationMiddleware(stack *middleware.Stack) error {
2290	return stack.Initialize.Add(&validateOpListResourceServers{}, middleware.After)
2291}
2292
2293func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
2294	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
2295}
2296
2297func addOpListUserImportJobsValidationMiddleware(stack *middleware.Stack) error {
2298	return stack.Initialize.Add(&validateOpListUserImportJobs{}, middleware.After)
2299}
2300
2301func addOpListUserPoolClientsValidationMiddleware(stack *middleware.Stack) error {
2302	return stack.Initialize.Add(&validateOpListUserPoolClients{}, middleware.After)
2303}
2304
2305func addOpListUserPoolsValidationMiddleware(stack *middleware.Stack) error {
2306	return stack.Initialize.Add(&validateOpListUserPools{}, middleware.After)
2307}
2308
2309func addOpListUsersInGroupValidationMiddleware(stack *middleware.Stack) error {
2310	return stack.Initialize.Add(&validateOpListUsersInGroup{}, middleware.After)
2311}
2312
2313func addOpListUsersValidationMiddleware(stack *middleware.Stack) error {
2314	return stack.Initialize.Add(&validateOpListUsers{}, middleware.After)
2315}
2316
2317func addOpResendConfirmationCodeValidationMiddleware(stack *middleware.Stack) error {
2318	return stack.Initialize.Add(&validateOpResendConfirmationCode{}, middleware.After)
2319}
2320
2321func addOpRespondToAuthChallengeValidationMiddleware(stack *middleware.Stack) error {
2322	return stack.Initialize.Add(&validateOpRespondToAuthChallenge{}, middleware.After)
2323}
2324
2325func addOpRevokeTokenValidationMiddleware(stack *middleware.Stack) error {
2326	return stack.Initialize.Add(&validateOpRevokeToken{}, middleware.After)
2327}
2328
2329func addOpSetRiskConfigurationValidationMiddleware(stack *middleware.Stack) error {
2330	return stack.Initialize.Add(&validateOpSetRiskConfiguration{}, middleware.After)
2331}
2332
2333func addOpSetUICustomizationValidationMiddleware(stack *middleware.Stack) error {
2334	return stack.Initialize.Add(&validateOpSetUICustomization{}, middleware.After)
2335}
2336
2337func addOpSetUserMFAPreferenceValidationMiddleware(stack *middleware.Stack) error {
2338	return stack.Initialize.Add(&validateOpSetUserMFAPreference{}, middleware.After)
2339}
2340
2341func addOpSetUserPoolMfaConfigValidationMiddleware(stack *middleware.Stack) error {
2342	return stack.Initialize.Add(&validateOpSetUserPoolMfaConfig{}, middleware.After)
2343}
2344
2345func addOpSetUserSettingsValidationMiddleware(stack *middleware.Stack) error {
2346	return stack.Initialize.Add(&validateOpSetUserSettings{}, middleware.After)
2347}
2348
2349func addOpSignUpValidationMiddleware(stack *middleware.Stack) error {
2350	return stack.Initialize.Add(&validateOpSignUp{}, middleware.After)
2351}
2352
2353func addOpStartUserImportJobValidationMiddleware(stack *middleware.Stack) error {
2354	return stack.Initialize.Add(&validateOpStartUserImportJob{}, middleware.After)
2355}
2356
2357func addOpStopUserImportJobValidationMiddleware(stack *middleware.Stack) error {
2358	return stack.Initialize.Add(&validateOpStopUserImportJob{}, middleware.After)
2359}
2360
2361func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
2362	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
2363}
2364
2365func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
2366	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
2367}
2368
2369func addOpUpdateAuthEventFeedbackValidationMiddleware(stack *middleware.Stack) error {
2370	return stack.Initialize.Add(&validateOpUpdateAuthEventFeedback{}, middleware.After)
2371}
2372
2373func addOpUpdateDeviceStatusValidationMiddleware(stack *middleware.Stack) error {
2374	return stack.Initialize.Add(&validateOpUpdateDeviceStatus{}, middleware.After)
2375}
2376
2377func addOpUpdateGroupValidationMiddleware(stack *middleware.Stack) error {
2378	return stack.Initialize.Add(&validateOpUpdateGroup{}, middleware.After)
2379}
2380
2381func addOpUpdateIdentityProviderValidationMiddleware(stack *middleware.Stack) error {
2382	return stack.Initialize.Add(&validateOpUpdateIdentityProvider{}, middleware.After)
2383}
2384
2385func addOpUpdateResourceServerValidationMiddleware(stack *middleware.Stack) error {
2386	return stack.Initialize.Add(&validateOpUpdateResourceServer{}, middleware.After)
2387}
2388
2389func addOpUpdateUserAttributesValidationMiddleware(stack *middleware.Stack) error {
2390	return stack.Initialize.Add(&validateOpUpdateUserAttributes{}, middleware.After)
2391}
2392
2393func addOpUpdateUserPoolClientValidationMiddleware(stack *middleware.Stack) error {
2394	return stack.Initialize.Add(&validateOpUpdateUserPoolClient{}, middleware.After)
2395}
2396
2397func addOpUpdateUserPoolDomainValidationMiddleware(stack *middleware.Stack) error {
2398	return stack.Initialize.Add(&validateOpUpdateUserPoolDomain{}, middleware.After)
2399}
2400
2401func addOpUpdateUserPoolValidationMiddleware(stack *middleware.Stack) error {
2402	return stack.Initialize.Add(&validateOpUpdateUserPool{}, middleware.After)
2403}
2404
2405func addOpVerifySoftwareTokenValidationMiddleware(stack *middleware.Stack) error {
2406	return stack.Initialize.Add(&validateOpVerifySoftwareToken{}, middleware.After)
2407}
2408
2409func addOpVerifyUserAttributeValidationMiddleware(stack *middleware.Stack) error {
2410	return stack.Initialize.Add(&validateOpVerifyUserAttribute{}, middleware.After)
2411}
2412
2413func validateAccountRecoverySettingType(v *types.AccountRecoverySettingType) error {
2414	if v == nil {
2415		return nil
2416	}
2417	invalidParams := smithy.InvalidParamsError{Context: "AccountRecoverySettingType"}
2418	if v.RecoveryMechanisms != nil {
2419		if err := validateRecoveryMechanismsType(v.RecoveryMechanisms); err != nil {
2420			invalidParams.AddNested("RecoveryMechanisms", err.(smithy.InvalidParamsError))
2421		}
2422	}
2423	if invalidParams.Len() > 0 {
2424		return invalidParams
2425	} else {
2426		return nil
2427	}
2428}
2429
2430func validateAccountTakeoverActionsType(v *types.AccountTakeoverActionsType) error {
2431	if v == nil {
2432		return nil
2433	}
2434	invalidParams := smithy.InvalidParamsError{Context: "AccountTakeoverActionsType"}
2435	if v.LowAction != nil {
2436		if err := validateAccountTakeoverActionType(v.LowAction); err != nil {
2437			invalidParams.AddNested("LowAction", err.(smithy.InvalidParamsError))
2438		}
2439	}
2440	if v.MediumAction != nil {
2441		if err := validateAccountTakeoverActionType(v.MediumAction); err != nil {
2442			invalidParams.AddNested("MediumAction", err.(smithy.InvalidParamsError))
2443		}
2444	}
2445	if v.HighAction != nil {
2446		if err := validateAccountTakeoverActionType(v.HighAction); err != nil {
2447			invalidParams.AddNested("HighAction", err.(smithy.InvalidParamsError))
2448		}
2449	}
2450	if invalidParams.Len() > 0 {
2451		return invalidParams
2452	} else {
2453		return nil
2454	}
2455}
2456
2457func validateAccountTakeoverActionType(v *types.AccountTakeoverActionType) error {
2458	if v == nil {
2459		return nil
2460	}
2461	invalidParams := smithy.InvalidParamsError{Context: "AccountTakeoverActionType"}
2462	if len(v.EventAction) == 0 {
2463		invalidParams.Add(smithy.NewErrParamRequired("EventAction"))
2464	}
2465	if invalidParams.Len() > 0 {
2466		return invalidParams
2467	} else {
2468		return nil
2469	}
2470}
2471
2472func validateAccountTakeoverRiskConfigurationType(v *types.AccountTakeoverRiskConfigurationType) error {
2473	if v == nil {
2474		return nil
2475	}
2476	invalidParams := smithy.InvalidParamsError{Context: "AccountTakeoverRiskConfigurationType"}
2477	if v.NotifyConfiguration != nil {
2478		if err := validateNotifyConfigurationType(v.NotifyConfiguration); err != nil {
2479			invalidParams.AddNested("NotifyConfiguration", err.(smithy.InvalidParamsError))
2480		}
2481	}
2482	if v.Actions == nil {
2483		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
2484	} else if v.Actions != nil {
2485		if err := validateAccountTakeoverActionsType(v.Actions); err != nil {
2486			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
2487		}
2488	}
2489	if invalidParams.Len() > 0 {
2490		return invalidParams
2491	} else {
2492		return nil
2493	}
2494}
2495
2496func validateAttributeListType(v []types.AttributeType) error {
2497	if v == nil {
2498		return nil
2499	}
2500	invalidParams := smithy.InvalidParamsError{Context: "AttributeListType"}
2501	for i := range v {
2502		if err := validateAttributeType(&v[i]); err != nil {
2503			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2504		}
2505	}
2506	if invalidParams.Len() > 0 {
2507		return invalidParams
2508	} else {
2509		return nil
2510	}
2511}
2512
2513func validateAttributeType(v *types.AttributeType) error {
2514	if v == nil {
2515		return nil
2516	}
2517	invalidParams := smithy.InvalidParamsError{Context: "AttributeType"}
2518	if v.Name == nil {
2519		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2520	}
2521	if invalidParams.Len() > 0 {
2522		return invalidParams
2523	} else {
2524		return nil
2525	}
2526}
2527
2528func validateCompromisedCredentialsActionsType(v *types.CompromisedCredentialsActionsType) error {
2529	if v == nil {
2530		return nil
2531	}
2532	invalidParams := smithy.InvalidParamsError{Context: "CompromisedCredentialsActionsType"}
2533	if len(v.EventAction) == 0 {
2534		invalidParams.Add(smithy.NewErrParamRequired("EventAction"))
2535	}
2536	if invalidParams.Len() > 0 {
2537		return invalidParams
2538	} else {
2539		return nil
2540	}
2541}
2542
2543func validateCompromisedCredentialsRiskConfigurationType(v *types.CompromisedCredentialsRiskConfigurationType) error {
2544	if v == nil {
2545		return nil
2546	}
2547	invalidParams := smithy.InvalidParamsError{Context: "CompromisedCredentialsRiskConfigurationType"}
2548	if v.Actions == nil {
2549		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
2550	} else if v.Actions != nil {
2551		if err := validateCompromisedCredentialsActionsType(v.Actions); err != nil {
2552			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
2553		}
2554	}
2555	if invalidParams.Len() > 0 {
2556		return invalidParams
2557	} else {
2558		return nil
2559	}
2560}
2561
2562func validateContextDataType(v *types.ContextDataType) error {
2563	if v == nil {
2564		return nil
2565	}
2566	invalidParams := smithy.InvalidParamsError{Context: "ContextDataType"}
2567	if v.IpAddress == nil {
2568		invalidParams.Add(smithy.NewErrParamRequired("IpAddress"))
2569	}
2570	if v.ServerName == nil {
2571		invalidParams.Add(smithy.NewErrParamRequired("ServerName"))
2572	}
2573	if v.ServerPath == nil {
2574		invalidParams.Add(smithy.NewErrParamRequired("ServerPath"))
2575	}
2576	if v.HttpHeaders == nil {
2577		invalidParams.Add(smithy.NewErrParamRequired("HttpHeaders"))
2578	}
2579	if invalidParams.Len() > 0 {
2580		return invalidParams
2581	} else {
2582		return nil
2583	}
2584}
2585
2586func validateCustomDomainConfigType(v *types.CustomDomainConfigType) error {
2587	if v == nil {
2588		return nil
2589	}
2590	invalidParams := smithy.InvalidParamsError{Context: "CustomDomainConfigType"}
2591	if v.CertificateArn == nil {
2592		invalidParams.Add(smithy.NewErrParamRequired("CertificateArn"))
2593	}
2594	if invalidParams.Len() > 0 {
2595		return invalidParams
2596	} else {
2597		return nil
2598	}
2599}
2600
2601func validateCustomEmailLambdaVersionConfigType(v *types.CustomEmailLambdaVersionConfigType) error {
2602	if v == nil {
2603		return nil
2604	}
2605	invalidParams := smithy.InvalidParamsError{Context: "CustomEmailLambdaVersionConfigType"}
2606	if len(v.LambdaVersion) == 0 {
2607		invalidParams.Add(smithy.NewErrParamRequired("LambdaVersion"))
2608	}
2609	if v.LambdaArn == nil {
2610		invalidParams.Add(smithy.NewErrParamRequired("LambdaArn"))
2611	}
2612	if invalidParams.Len() > 0 {
2613		return invalidParams
2614	} else {
2615		return nil
2616	}
2617}
2618
2619func validateCustomSMSLambdaVersionConfigType(v *types.CustomSMSLambdaVersionConfigType) error {
2620	if v == nil {
2621		return nil
2622	}
2623	invalidParams := smithy.InvalidParamsError{Context: "CustomSMSLambdaVersionConfigType"}
2624	if len(v.LambdaVersion) == 0 {
2625		invalidParams.Add(smithy.NewErrParamRequired("LambdaVersion"))
2626	}
2627	if v.LambdaArn == nil {
2628		invalidParams.Add(smithy.NewErrParamRequired("LambdaArn"))
2629	}
2630	if invalidParams.Len() > 0 {
2631		return invalidParams
2632	} else {
2633		return nil
2634	}
2635}
2636
2637func validateLambdaConfigType(v *types.LambdaConfigType) error {
2638	if v == nil {
2639		return nil
2640	}
2641	invalidParams := smithy.InvalidParamsError{Context: "LambdaConfigType"}
2642	if v.CustomSMSSender != nil {
2643		if err := validateCustomSMSLambdaVersionConfigType(v.CustomSMSSender); err != nil {
2644			invalidParams.AddNested("CustomSMSSender", err.(smithy.InvalidParamsError))
2645		}
2646	}
2647	if v.CustomEmailSender != nil {
2648		if err := validateCustomEmailLambdaVersionConfigType(v.CustomEmailSender); err != nil {
2649			invalidParams.AddNested("CustomEmailSender", err.(smithy.InvalidParamsError))
2650		}
2651	}
2652	if invalidParams.Len() > 0 {
2653		return invalidParams
2654	} else {
2655		return nil
2656	}
2657}
2658
2659func validateNotifyConfigurationType(v *types.NotifyConfigurationType) error {
2660	if v == nil {
2661		return nil
2662	}
2663	invalidParams := smithy.InvalidParamsError{Context: "NotifyConfigurationType"}
2664	if v.SourceArn == nil {
2665		invalidParams.Add(smithy.NewErrParamRequired("SourceArn"))
2666	}
2667	if v.BlockEmail != nil {
2668		if err := validateNotifyEmailType(v.BlockEmail); err != nil {
2669			invalidParams.AddNested("BlockEmail", err.(smithy.InvalidParamsError))
2670		}
2671	}
2672	if v.NoActionEmail != nil {
2673		if err := validateNotifyEmailType(v.NoActionEmail); err != nil {
2674			invalidParams.AddNested("NoActionEmail", err.(smithy.InvalidParamsError))
2675		}
2676	}
2677	if v.MfaEmail != nil {
2678		if err := validateNotifyEmailType(v.MfaEmail); err != nil {
2679			invalidParams.AddNested("MfaEmail", err.(smithy.InvalidParamsError))
2680		}
2681	}
2682	if invalidParams.Len() > 0 {
2683		return invalidParams
2684	} else {
2685		return nil
2686	}
2687}
2688
2689func validateNotifyEmailType(v *types.NotifyEmailType) error {
2690	if v == nil {
2691		return nil
2692	}
2693	invalidParams := smithy.InvalidParamsError{Context: "NotifyEmailType"}
2694	if v.Subject == nil {
2695		invalidParams.Add(smithy.NewErrParamRequired("Subject"))
2696	}
2697	if invalidParams.Len() > 0 {
2698		return invalidParams
2699	} else {
2700		return nil
2701	}
2702}
2703
2704func validateRecoveryMechanismsType(v []types.RecoveryOptionType) error {
2705	if v == nil {
2706		return nil
2707	}
2708	invalidParams := smithy.InvalidParamsError{Context: "RecoveryMechanismsType"}
2709	for i := range v {
2710		if err := validateRecoveryOptionType(&v[i]); err != nil {
2711			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2712		}
2713	}
2714	if invalidParams.Len() > 0 {
2715		return invalidParams
2716	} else {
2717		return nil
2718	}
2719}
2720
2721func validateRecoveryOptionType(v *types.RecoveryOptionType) error {
2722	if v == nil {
2723		return nil
2724	}
2725	invalidParams := smithy.InvalidParamsError{Context: "RecoveryOptionType"}
2726	if len(v.Name) == 0 {
2727		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2728	}
2729	if invalidParams.Len() > 0 {
2730		return invalidParams
2731	} else {
2732		return nil
2733	}
2734}
2735
2736func validateResourceServerScopeListType(v []types.ResourceServerScopeType) error {
2737	if v == nil {
2738		return nil
2739	}
2740	invalidParams := smithy.InvalidParamsError{Context: "ResourceServerScopeListType"}
2741	for i := range v {
2742		if err := validateResourceServerScopeType(&v[i]); err != nil {
2743			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2744		}
2745	}
2746	if invalidParams.Len() > 0 {
2747		return invalidParams
2748	} else {
2749		return nil
2750	}
2751}
2752
2753func validateResourceServerScopeType(v *types.ResourceServerScopeType) error {
2754	if v == nil {
2755		return nil
2756	}
2757	invalidParams := smithy.InvalidParamsError{Context: "ResourceServerScopeType"}
2758	if v.ScopeName == nil {
2759		invalidParams.Add(smithy.NewErrParamRequired("ScopeName"))
2760	}
2761	if v.ScopeDescription == nil {
2762		invalidParams.Add(smithy.NewErrParamRequired("ScopeDescription"))
2763	}
2764	if invalidParams.Len() > 0 {
2765		return invalidParams
2766	} else {
2767		return nil
2768	}
2769}
2770
2771func validateSmsConfigurationType(v *types.SmsConfigurationType) error {
2772	if v == nil {
2773		return nil
2774	}
2775	invalidParams := smithy.InvalidParamsError{Context: "SmsConfigurationType"}
2776	if v.SnsCallerArn == nil {
2777		invalidParams.Add(smithy.NewErrParamRequired("SnsCallerArn"))
2778	}
2779	if invalidParams.Len() > 0 {
2780		return invalidParams
2781	} else {
2782		return nil
2783	}
2784}
2785
2786func validateSmsMfaConfigType(v *types.SmsMfaConfigType) error {
2787	if v == nil {
2788		return nil
2789	}
2790	invalidParams := smithy.InvalidParamsError{Context: "SmsMfaConfigType"}
2791	if v.SmsConfiguration != nil {
2792		if err := validateSmsConfigurationType(v.SmsConfiguration); err != nil {
2793			invalidParams.AddNested("SmsConfiguration", err.(smithy.InvalidParamsError))
2794		}
2795	}
2796	if invalidParams.Len() > 0 {
2797		return invalidParams
2798	} else {
2799		return nil
2800	}
2801}
2802
2803func validateUsernameConfigurationType(v *types.UsernameConfigurationType) error {
2804	if v == nil {
2805		return nil
2806	}
2807	invalidParams := smithy.InvalidParamsError{Context: "UsernameConfigurationType"}
2808	if v.CaseSensitive == nil {
2809		invalidParams.Add(smithy.NewErrParamRequired("CaseSensitive"))
2810	}
2811	if invalidParams.Len() > 0 {
2812		return invalidParams
2813	} else {
2814		return nil
2815	}
2816}
2817
2818func validateUserPoolAddOnsType(v *types.UserPoolAddOnsType) error {
2819	if v == nil {
2820		return nil
2821	}
2822	invalidParams := smithy.InvalidParamsError{Context: "UserPoolAddOnsType"}
2823	if len(v.AdvancedSecurityMode) == 0 {
2824		invalidParams.Add(smithy.NewErrParamRequired("AdvancedSecurityMode"))
2825	}
2826	if invalidParams.Len() > 0 {
2827		return invalidParams
2828	} else {
2829		return nil
2830	}
2831}
2832
2833func validateOpAddCustomAttributesInput(v *AddCustomAttributesInput) error {
2834	if v == nil {
2835		return nil
2836	}
2837	invalidParams := smithy.InvalidParamsError{Context: "AddCustomAttributesInput"}
2838	if v.UserPoolId == nil {
2839		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
2840	}
2841	if v.CustomAttributes == nil {
2842		invalidParams.Add(smithy.NewErrParamRequired("CustomAttributes"))
2843	}
2844	if invalidParams.Len() > 0 {
2845		return invalidParams
2846	} else {
2847		return nil
2848	}
2849}
2850
2851func validateOpAdminAddUserToGroupInput(v *AdminAddUserToGroupInput) error {
2852	if v == nil {
2853		return nil
2854	}
2855	invalidParams := smithy.InvalidParamsError{Context: "AdminAddUserToGroupInput"}
2856	if v.UserPoolId == nil {
2857		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
2858	}
2859	if v.Username == nil {
2860		invalidParams.Add(smithy.NewErrParamRequired("Username"))
2861	}
2862	if v.GroupName == nil {
2863		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
2864	}
2865	if invalidParams.Len() > 0 {
2866		return invalidParams
2867	} else {
2868		return nil
2869	}
2870}
2871
2872func validateOpAdminConfirmSignUpInput(v *AdminConfirmSignUpInput) error {
2873	if v == nil {
2874		return nil
2875	}
2876	invalidParams := smithy.InvalidParamsError{Context: "AdminConfirmSignUpInput"}
2877	if v.UserPoolId == nil {
2878		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
2879	}
2880	if v.Username == nil {
2881		invalidParams.Add(smithy.NewErrParamRequired("Username"))
2882	}
2883	if invalidParams.Len() > 0 {
2884		return invalidParams
2885	} else {
2886		return nil
2887	}
2888}
2889
2890func validateOpAdminCreateUserInput(v *AdminCreateUserInput) error {
2891	if v == nil {
2892		return nil
2893	}
2894	invalidParams := smithy.InvalidParamsError{Context: "AdminCreateUserInput"}
2895	if v.UserPoolId == nil {
2896		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
2897	}
2898	if v.Username == nil {
2899		invalidParams.Add(smithy.NewErrParamRequired("Username"))
2900	}
2901	if v.UserAttributes != nil {
2902		if err := validateAttributeListType(v.UserAttributes); err != nil {
2903			invalidParams.AddNested("UserAttributes", err.(smithy.InvalidParamsError))
2904		}
2905	}
2906	if v.ValidationData != nil {
2907		if err := validateAttributeListType(v.ValidationData); err != nil {
2908			invalidParams.AddNested("ValidationData", err.(smithy.InvalidParamsError))
2909		}
2910	}
2911	if invalidParams.Len() > 0 {
2912		return invalidParams
2913	} else {
2914		return nil
2915	}
2916}
2917
2918func validateOpAdminDeleteUserAttributesInput(v *AdminDeleteUserAttributesInput) error {
2919	if v == nil {
2920		return nil
2921	}
2922	invalidParams := smithy.InvalidParamsError{Context: "AdminDeleteUserAttributesInput"}
2923	if v.UserPoolId == nil {
2924		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
2925	}
2926	if v.Username == nil {
2927		invalidParams.Add(smithy.NewErrParamRequired("Username"))
2928	}
2929	if v.UserAttributeNames == nil {
2930		invalidParams.Add(smithy.NewErrParamRequired("UserAttributeNames"))
2931	}
2932	if invalidParams.Len() > 0 {
2933		return invalidParams
2934	} else {
2935		return nil
2936	}
2937}
2938
2939func validateOpAdminDeleteUserInput(v *AdminDeleteUserInput) error {
2940	if v == nil {
2941		return nil
2942	}
2943	invalidParams := smithy.InvalidParamsError{Context: "AdminDeleteUserInput"}
2944	if v.UserPoolId == nil {
2945		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
2946	}
2947	if v.Username == nil {
2948		invalidParams.Add(smithy.NewErrParamRequired("Username"))
2949	}
2950	if invalidParams.Len() > 0 {
2951		return invalidParams
2952	} else {
2953		return nil
2954	}
2955}
2956
2957func validateOpAdminDisableProviderForUserInput(v *AdminDisableProviderForUserInput) error {
2958	if v == nil {
2959		return nil
2960	}
2961	invalidParams := smithy.InvalidParamsError{Context: "AdminDisableProviderForUserInput"}
2962	if v.UserPoolId == nil {
2963		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
2964	}
2965	if v.User == nil {
2966		invalidParams.Add(smithy.NewErrParamRequired("User"))
2967	}
2968	if invalidParams.Len() > 0 {
2969		return invalidParams
2970	} else {
2971		return nil
2972	}
2973}
2974
2975func validateOpAdminDisableUserInput(v *AdminDisableUserInput) error {
2976	if v == nil {
2977		return nil
2978	}
2979	invalidParams := smithy.InvalidParamsError{Context: "AdminDisableUserInput"}
2980	if v.UserPoolId == nil {
2981		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
2982	}
2983	if v.Username == nil {
2984		invalidParams.Add(smithy.NewErrParamRequired("Username"))
2985	}
2986	if invalidParams.Len() > 0 {
2987		return invalidParams
2988	} else {
2989		return nil
2990	}
2991}
2992
2993func validateOpAdminEnableUserInput(v *AdminEnableUserInput) error {
2994	if v == nil {
2995		return nil
2996	}
2997	invalidParams := smithy.InvalidParamsError{Context: "AdminEnableUserInput"}
2998	if v.UserPoolId == nil {
2999		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3000	}
3001	if v.Username == nil {
3002		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3003	}
3004	if invalidParams.Len() > 0 {
3005		return invalidParams
3006	} else {
3007		return nil
3008	}
3009}
3010
3011func validateOpAdminForgetDeviceInput(v *AdminForgetDeviceInput) error {
3012	if v == nil {
3013		return nil
3014	}
3015	invalidParams := smithy.InvalidParamsError{Context: "AdminForgetDeviceInput"}
3016	if v.UserPoolId == nil {
3017		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3018	}
3019	if v.Username == nil {
3020		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3021	}
3022	if v.DeviceKey == nil {
3023		invalidParams.Add(smithy.NewErrParamRequired("DeviceKey"))
3024	}
3025	if invalidParams.Len() > 0 {
3026		return invalidParams
3027	} else {
3028		return nil
3029	}
3030}
3031
3032func validateOpAdminGetDeviceInput(v *AdminGetDeviceInput) error {
3033	if v == nil {
3034		return nil
3035	}
3036	invalidParams := smithy.InvalidParamsError{Context: "AdminGetDeviceInput"}
3037	if v.DeviceKey == nil {
3038		invalidParams.Add(smithy.NewErrParamRequired("DeviceKey"))
3039	}
3040	if v.UserPoolId == nil {
3041		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3042	}
3043	if v.Username == nil {
3044		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3045	}
3046	if invalidParams.Len() > 0 {
3047		return invalidParams
3048	} else {
3049		return nil
3050	}
3051}
3052
3053func validateOpAdminGetUserInput(v *AdminGetUserInput) error {
3054	if v == nil {
3055		return nil
3056	}
3057	invalidParams := smithy.InvalidParamsError{Context: "AdminGetUserInput"}
3058	if v.UserPoolId == nil {
3059		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3060	}
3061	if v.Username == nil {
3062		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3063	}
3064	if invalidParams.Len() > 0 {
3065		return invalidParams
3066	} else {
3067		return nil
3068	}
3069}
3070
3071func validateOpAdminInitiateAuthInput(v *AdminInitiateAuthInput) error {
3072	if v == nil {
3073		return nil
3074	}
3075	invalidParams := smithy.InvalidParamsError{Context: "AdminInitiateAuthInput"}
3076	if v.UserPoolId == nil {
3077		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3078	}
3079	if v.ClientId == nil {
3080		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
3081	}
3082	if len(v.AuthFlow) == 0 {
3083		invalidParams.Add(smithy.NewErrParamRequired("AuthFlow"))
3084	}
3085	if v.ContextData != nil {
3086		if err := validateContextDataType(v.ContextData); err != nil {
3087			invalidParams.AddNested("ContextData", err.(smithy.InvalidParamsError))
3088		}
3089	}
3090	if invalidParams.Len() > 0 {
3091		return invalidParams
3092	} else {
3093		return nil
3094	}
3095}
3096
3097func validateOpAdminLinkProviderForUserInput(v *AdminLinkProviderForUserInput) error {
3098	if v == nil {
3099		return nil
3100	}
3101	invalidParams := smithy.InvalidParamsError{Context: "AdminLinkProviderForUserInput"}
3102	if v.UserPoolId == nil {
3103		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3104	}
3105	if v.DestinationUser == nil {
3106		invalidParams.Add(smithy.NewErrParamRequired("DestinationUser"))
3107	}
3108	if v.SourceUser == nil {
3109		invalidParams.Add(smithy.NewErrParamRequired("SourceUser"))
3110	}
3111	if invalidParams.Len() > 0 {
3112		return invalidParams
3113	} else {
3114		return nil
3115	}
3116}
3117
3118func validateOpAdminListDevicesInput(v *AdminListDevicesInput) error {
3119	if v == nil {
3120		return nil
3121	}
3122	invalidParams := smithy.InvalidParamsError{Context: "AdminListDevicesInput"}
3123	if v.UserPoolId == nil {
3124		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3125	}
3126	if v.Username == nil {
3127		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3128	}
3129	if invalidParams.Len() > 0 {
3130		return invalidParams
3131	} else {
3132		return nil
3133	}
3134}
3135
3136func validateOpAdminListGroupsForUserInput(v *AdminListGroupsForUserInput) error {
3137	if v == nil {
3138		return nil
3139	}
3140	invalidParams := smithy.InvalidParamsError{Context: "AdminListGroupsForUserInput"}
3141	if v.Username == nil {
3142		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3143	}
3144	if v.UserPoolId == nil {
3145		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3146	}
3147	if invalidParams.Len() > 0 {
3148		return invalidParams
3149	} else {
3150		return nil
3151	}
3152}
3153
3154func validateOpAdminListUserAuthEventsInput(v *AdminListUserAuthEventsInput) error {
3155	if v == nil {
3156		return nil
3157	}
3158	invalidParams := smithy.InvalidParamsError{Context: "AdminListUserAuthEventsInput"}
3159	if v.UserPoolId == nil {
3160		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3161	}
3162	if v.Username == nil {
3163		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3164	}
3165	if invalidParams.Len() > 0 {
3166		return invalidParams
3167	} else {
3168		return nil
3169	}
3170}
3171
3172func validateOpAdminRemoveUserFromGroupInput(v *AdminRemoveUserFromGroupInput) error {
3173	if v == nil {
3174		return nil
3175	}
3176	invalidParams := smithy.InvalidParamsError{Context: "AdminRemoveUserFromGroupInput"}
3177	if v.UserPoolId == nil {
3178		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3179	}
3180	if v.Username == nil {
3181		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3182	}
3183	if v.GroupName == nil {
3184		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
3185	}
3186	if invalidParams.Len() > 0 {
3187		return invalidParams
3188	} else {
3189		return nil
3190	}
3191}
3192
3193func validateOpAdminResetUserPasswordInput(v *AdminResetUserPasswordInput) error {
3194	if v == nil {
3195		return nil
3196	}
3197	invalidParams := smithy.InvalidParamsError{Context: "AdminResetUserPasswordInput"}
3198	if v.UserPoolId == nil {
3199		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3200	}
3201	if v.Username == nil {
3202		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3203	}
3204	if invalidParams.Len() > 0 {
3205		return invalidParams
3206	} else {
3207		return nil
3208	}
3209}
3210
3211func validateOpAdminRespondToAuthChallengeInput(v *AdminRespondToAuthChallengeInput) error {
3212	if v == nil {
3213		return nil
3214	}
3215	invalidParams := smithy.InvalidParamsError{Context: "AdminRespondToAuthChallengeInput"}
3216	if v.UserPoolId == nil {
3217		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3218	}
3219	if v.ClientId == nil {
3220		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
3221	}
3222	if len(v.ChallengeName) == 0 {
3223		invalidParams.Add(smithy.NewErrParamRequired("ChallengeName"))
3224	}
3225	if v.ContextData != nil {
3226		if err := validateContextDataType(v.ContextData); err != nil {
3227			invalidParams.AddNested("ContextData", err.(smithy.InvalidParamsError))
3228		}
3229	}
3230	if invalidParams.Len() > 0 {
3231		return invalidParams
3232	} else {
3233		return nil
3234	}
3235}
3236
3237func validateOpAdminSetUserMFAPreferenceInput(v *AdminSetUserMFAPreferenceInput) error {
3238	if v == nil {
3239		return nil
3240	}
3241	invalidParams := smithy.InvalidParamsError{Context: "AdminSetUserMFAPreferenceInput"}
3242	if v.Username == nil {
3243		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3244	}
3245	if v.UserPoolId == nil {
3246		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3247	}
3248	if invalidParams.Len() > 0 {
3249		return invalidParams
3250	} else {
3251		return nil
3252	}
3253}
3254
3255func validateOpAdminSetUserPasswordInput(v *AdminSetUserPasswordInput) error {
3256	if v == nil {
3257		return nil
3258	}
3259	invalidParams := smithy.InvalidParamsError{Context: "AdminSetUserPasswordInput"}
3260	if v.UserPoolId == nil {
3261		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3262	}
3263	if v.Username == nil {
3264		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3265	}
3266	if v.Password == nil {
3267		invalidParams.Add(smithy.NewErrParamRequired("Password"))
3268	}
3269	if invalidParams.Len() > 0 {
3270		return invalidParams
3271	} else {
3272		return nil
3273	}
3274}
3275
3276func validateOpAdminSetUserSettingsInput(v *AdminSetUserSettingsInput) error {
3277	if v == nil {
3278		return nil
3279	}
3280	invalidParams := smithy.InvalidParamsError{Context: "AdminSetUserSettingsInput"}
3281	if v.UserPoolId == nil {
3282		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3283	}
3284	if v.Username == nil {
3285		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3286	}
3287	if v.MFAOptions == nil {
3288		invalidParams.Add(smithy.NewErrParamRequired("MFAOptions"))
3289	}
3290	if invalidParams.Len() > 0 {
3291		return invalidParams
3292	} else {
3293		return nil
3294	}
3295}
3296
3297func validateOpAdminUpdateAuthEventFeedbackInput(v *AdminUpdateAuthEventFeedbackInput) error {
3298	if v == nil {
3299		return nil
3300	}
3301	invalidParams := smithy.InvalidParamsError{Context: "AdminUpdateAuthEventFeedbackInput"}
3302	if v.UserPoolId == nil {
3303		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3304	}
3305	if v.Username == nil {
3306		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3307	}
3308	if v.EventId == nil {
3309		invalidParams.Add(smithy.NewErrParamRequired("EventId"))
3310	}
3311	if len(v.FeedbackValue) == 0 {
3312		invalidParams.Add(smithy.NewErrParamRequired("FeedbackValue"))
3313	}
3314	if invalidParams.Len() > 0 {
3315		return invalidParams
3316	} else {
3317		return nil
3318	}
3319}
3320
3321func validateOpAdminUpdateDeviceStatusInput(v *AdminUpdateDeviceStatusInput) error {
3322	if v == nil {
3323		return nil
3324	}
3325	invalidParams := smithy.InvalidParamsError{Context: "AdminUpdateDeviceStatusInput"}
3326	if v.UserPoolId == nil {
3327		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3328	}
3329	if v.Username == nil {
3330		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3331	}
3332	if v.DeviceKey == nil {
3333		invalidParams.Add(smithy.NewErrParamRequired("DeviceKey"))
3334	}
3335	if invalidParams.Len() > 0 {
3336		return invalidParams
3337	} else {
3338		return nil
3339	}
3340}
3341
3342func validateOpAdminUpdateUserAttributesInput(v *AdminUpdateUserAttributesInput) error {
3343	if v == nil {
3344		return nil
3345	}
3346	invalidParams := smithy.InvalidParamsError{Context: "AdminUpdateUserAttributesInput"}
3347	if v.UserPoolId == nil {
3348		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3349	}
3350	if v.Username == nil {
3351		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3352	}
3353	if v.UserAttributes == nil {
3354		invalidParams.Add(smithy.NewErrParamRequired("UserAttributes"))
3355	} else if v.UserAttributes != nil {
3356		if err := validateAttributeListType(v.UserAttributes); err != nil {
3357			invalidParams.AddNested("UserAttributes", err.(smithy.InvalidParamsError))
3358		}
3359	}
3360	if invalidParams.Len() > 0 {
3361		return invalidParams
3362	} else {
3363		return nil
3364	}
3365}
3366
3367func validateOpAdminUserGlobalSignOutInput(v *AdminUserGlobalSignOutInput) error {
3368	if v == nil {
3369		return nil
3370	}
3371	invalidParams := smithy.InvalidParamsError{Context: "AdminUserGlobalSignOutInput"}
3372	if v.UserPoolId == nil {
3373		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3374	}
3375	if v.Username == nil {
3376		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3377	}
3378	if invalidParams.Len() > 0 {
3379		return invalidParams
3380	} else {
3381		return nil
3382	}
3383}
3384
3385func validateOpChangePasswordInput(v *ChangePasswordInput) error {
3386	if v == nil {
3387		return nil
3388	}
3389	invalidParams := smithy.InvalidParamsError{Context: "ChangePasswordInput"}
3390	if v.PreviousPassword == nil {
3391		invalidParams.Add(smithy.NewErrParamRequired("PreviousPassword"))
3392	}
3393	if v.ProposedPassword == nil {
3394		invalidParams.Add(smithy.NewErrParamRequired("ProposedPassword"))
3395	}
3396	if v.AccessToken == nil {
3397		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
3398	}
3399	if invalidParams.Len() > 0 {
3400		return invalidParams
3401	} else {
3402		return nil
3403	}
3404}
3405
3406func validateOpConfirmDeviceInput(v *ConfirmDeviceInput) error {
3407	if v == nil {
3408		return nil
3409	}
3410	invalidParams := smithy.InvalidParamsError{Context: "ConfirmDeviceInput"}
3411	if v.AccessToken == nil {
3412		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
3413	}
3414	if v.DeviceKey == nil {
3415		invalidParams.Add(smithy.NewErrParamRequired("DeviceKey"))
3416	}
3417	if invalidParams.Len() > 0 {
3418		return invalidParams
3419	} else {
3420		return nil
3421	}
3422}
3423
3424func validateOpConfirmForgotPasswordInput(v *ConfirmForgotPasswordInput) error {
3425	if v == nil {
3426		return nil
3427	}
3428	invalidParams := smithy.InvalidParamsError{Context: "ConfirmForgotPasswordInput"}
3429	if v.ClientId == nil {
3430		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
3431	}
3432	if v.Username == nil {
3433		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3434	}
3435	if v.ConfirmationCode == nil {
3436		invalidParams.Add(smithy.NewErrParamRequired("ConfirmationCode"))
3437	}
3438	if v.Password == nil {
3439		invalidParams.Add(smithy.NewErrParamRequired("Password"))
3440	}
3441	if invalidParams.Len() > 0 {
3442		return invalidParams
3443	} else {
3444		return nil
3445	}
3446}
3447
3448func validateOpConfirmSignUpInput(v *ConfirmSignUpInput) error {
3449	if v == nil {
3450		return nil
3451	}
3452	invalidParams := smithy.InvalidParamsError{Context: "ConfirmSignUpInput"}
3453	if v.ClientId == nil {
3454		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
3455	}
3456	if v.Username == nil {
3457		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3458	}
3459	if v.ConfirmationCode == nil {
3460		invalidParams.Add(smithy.NewErrParamRequired("ConfirmationCode"))
3461	}
3462	if invalidParams.Len() > 0 {
3463		return invalidParams
3464	} else {
3465		return nil
3466	}
3467}
3468
3469func validateOpCreateGroupInput(v *CreateGroupInput) error {
3470	if v == nil {
3471		return nil
3472	}
3473	invalidParams := smithy.InvalidParamsError{Context: "CreateGroupInput"}
3474	if v.GroupName == nil {
3475		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
3476	}
3477	if v.UserPoolId == nil {
3478		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3479	}
3480	if invalidParams.Len() > 0 {
3481		return invalidParams
3482	} else {
3483		return nil
3484	}
3485}
3486
3487func validateOpCreateIdentityProviderInput(v *CreateIdentityProviderInput) error {
3488	if v == nil {
3489		return nil
3490	}
3491	invalidParams := smithy.InvalidParamsError{Context: "CreateIdentityProviderInput"}
3492	if v.UserPoolId == nil {
3493		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3494	}
3495	if v.ProviderName == nil {
3496		invalidParams.Add(smithy.NewErrParamRequired("ProviderName"))
3497	}
3498	if len(v.ProviderType) == 0 {
3499		invalidParams.Add(smithy.NewErrParamRequired("ProviderType"))
3500	}
3501	if v.ProviderDetails == nil {
3502		invalidParams.Add(smithy.NewErrParamRequired("ProviderDetails"))
3503	}
3504	if invalidParams.Len() > 0 {
3505		return invalidParams
3506	} else {
3507		return nil
3508	}
3509}
3510
3511func validateOpCreateResourceServerInput(v *CreateResourceServerInput) error {
3512	if v == nil {
3513		return nil
3514	}
3515	invalidParams := smithy.InvalidParamsError{Context: "CreateResourceServerInput"}
3516	if v.UserPoolId == nil {
3517		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3518	}
3519	if v.Identifier == nil {
3520		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
3521	}
3522	if v.Name == nil {
3523		invalidParams.Add(smithy.NewErrParamRequired("Name"))
3524	}
3525	if v.Scopes != nil {
3526		if err := validateResourceServerScopeListType(v.Scopes); err != nil {
3527			invalidParams.AddNested("Scopes", err.(smithy.InvalidParamsError))
3528		}
3529	}
3530	if invalidParams.Len() > 0 {
3531		return invalidParams
3532	} else {
3533		return nil
3534	}
3535}
3536
3537func validateOpCreateUserImportJobInput(v *CreateUserImportJobInput) error {
3538	if v == nil {
3539		return nil
3540	}
3541	invalidParams := smithy.InvalidParamsError{Context: "CreateUserImportJobInput"}
3542	if v.JobName == nil {
3543		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
3544	}
3545	if v.UserPoolId == nil {
3546		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3547	}
3548	if v.CloudWatchLogsRoleArn == nil {
3549		invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLogsRoleArn"))
3550	}
3551	if invalidParams.Len() > 0 {
3552		return invalidParams
3553	} else {
3554		return nil
3555	}
3556}
3557
3558func validateOpCreateUserPoolClientInput(v *CreateUserPoolClientInput) error {
3559	if v == nil {
3560		return nil
3561	}
3562	invalidParams := smithy.InvalidParamsError{Context: "CreateUserPoolClientInput"}
3563	if v.UserPoolId == nil {
3564		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3565	}
3566	if v.ClientName == nil {
3567		invalidParams.Add(smithy.NewErrParamRequired("ClientName"))
3568	}
3569	if invalidParams.Len() > 0 {
3570		return invalidParams
3571	} else {
3572		return nil
3573	}
3574}
3575
3576func validateOpCreateUserPoolDomainInput(v *CreateUserPoolDomainInput) error {
3577	if v == nil {
3578		return nil
3579	}
3580	invalidParams := smithy.InvalidParamsError{Context: "CreateUserPoolDomainInput"}
3581	if v.Domain == nil {
3582		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
3583	}
3584	if v.UserPoolId == nil {
3585		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3586	}
3587	if v.CustomDomainConfig != nil {
3588		if err := validateCustomDomainConfigType(v.CustomDomainConfig); err != nil {
3589			invalidParams.AddNested("CustomDomainConfig", err.(smithy.InvalidParamsError))
3590		}
3591	}
3592	if invalidParams.Len() > 0 {
3593		return invalidParams
3594	} else {
3595		return nil
3596	}
3597}
3598
3599func validateOpCreateUserPoolInput(v *CreateUserPoolInput) error {
3600	if v == nil {
3601		return nil
3602	}
3603	invalidParams := smithy.InvalidParamsError{Context: "CreateUserPoolInput"}
3604	if v.PoolName == nil {
3605		invalidParams.Add(smithy.NewErrParamRequired("PoolName"))
3606	}
3607	if v.LambdaConfig != nil {
3608		if err := validateLambdaConfigType(v.LambdaConfig); err != nil {
3609			invalidParams.AddNested("LambdaConfig", err.(smithy.InvalidParamsError))
3610		}
3611	}
3612	if v.SmsConfiguration != nil {
3613		if err := validateSmsConfigurationType(v.SmsConfiguration); err != nil {
3614			invalidParams.AddNested("SmsConfiguration", err.(smithy.InvalidParamsError))
3615		}
3616	}
3617	if v.UserPoolAddOns != nil {
3618		if err := validateUserPoolAddOnsType(v.UserPoolAddOns); err != nil {
3619			invalidParams.AddNested("UserPoolAddOns", err.(smithy.InvalidParamsError))
3620		}
3621	}
3622	if v.UsernameConfiguration != nil {
3623		if err := validateUsernameConfigurationType(v.UsernameConfiguration); err != nil {
3624			invalidParams.AddNested("UsernameConfiguration", err.(smithy.InvalidParamsError))
3625		}
3626	}
3627	if v.AccountRecoverySetting != nil {
3628		if err := validateAccountRecoverySettingType(v.AccountRecoverySetting); err != nil {
3629			invalidParams.AddNested("AccountRecoverySetting", err.(smithy.InvalidParamsError))
3630		}
3631	}
3632	if invalidParams.Len() > 0 {
3633		return invalidParams
3634	} else {
3635		return nil
3636	}
3637}
3638
3639func validateOpDeleteGroupInput(v *DeleteGroupInput) error {
3640	if v == nil {
3641		return nil
3642	}
3643	invalidParams := smithy.InvalidParamsError{Context: "DeleteGroupInput"}
3644	if v.GroupName == nil {
3645		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
3646	}
3647	if v.UserPoolId == nil {
3648		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3649	}
3650	if invalidParams.Len() > 0 {
3651		return invalidParams
3652	} else {
3653		return nil
3654	}
3655}
3656
3657func validateOpDeleteIdentityProviderInput(v *DeleteIdentityProviderInput) error {
3658	if v == nil {
3659		return nil
3660	}
3661	invalidParams := smithy.InvalidParamsError{Context: "DeleteIdentityProviderInput"}
3662	if v.UserPoolId == nil {
3663		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3664	}
3665	if v.ProviderName == nil {
3666		invalidParams.Add(smithy.NewErrParamRequired("ProviderName"))
3667	}
3668	if invalidParams.Len() > 0 {
3669		return invalidParams
3670	} else {
3671		return nil
3672	}
3673}
3674
3675func validateOpDeleteResourceServerInput(v *DeleteResourceServerInput) error {
3676	if v == nil {
3677		return nil
3678	}
3679	invalidParams := smithy.InvalidParamsError{Context: "DeleteResourceServerInput"}
3680	if v.UserPoolId == nil {
3681		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3682	}
3683	if v.Identifier == nil {
3684		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
3685	}
3686	if invalidParams.Len() > 0 {
3687		return invalidParams
3688	} else {
3689		return nil
3690	}
3691}
3692
3693func validateOpDeleteUserAttributesInput(v *DeleteUserAttributesInput) error {
3694	if v == nil {
3695		return nil
3696	}
3697	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserAttributesInput"}
3698	if v.UserAttributeNames == nil {
3699		invalidParams.Add(smithy.NewErrParamRequired("UserAttributeNames"))
3700	}
3701	if v.AccessToken == nil {
3702		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
3703	}
3704	if invalidParams.Len() > 0 {
3705		return invalidParams
3706	} else {
3707		return nil
3708	}
3709}
3710
3711func validateOpDeleteUserInput(v *DeleteUserInput) error {
3712	if v == nil {
3713		return nil
3714	}
3715	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserInput"}
3716	if v.AccessToken == nil {
3717		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
3718	}
3719	if invalidParams.Len() > 0 {
3720		return invalidParams
3721	} else {
3722		return nil
3723	}
3724}
3725
3726func validateOpDeleteUserPoolClientInput(v *DeleteUserPoolClientInput) error {
3727	if v == nil {
3728		return nil
3729	}
3730	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserPoolClientInput"}
3731	if v.UserPoolId == nil {
3732		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3733	}
3734	if v.ClientId == nil {
3735		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
3736	}
3737	if invalidParams.Len() > 0 {
3738		return invalidParams
3739	} else {
3740		return nil
3741	}
3742}
3743
3744func validateOpDeleteUserPoolDomainInput(v *DeleteUserPoolDomainInput) error {
3745	if v == nil {
3746		return nil
3747	}
3748	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserPoolDomainInput"}
3749	if v.Domain == nil {
3750		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
3751	}
3752	if v.UserPoolId == nil {
3753		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3754	}
3755	if invalidParams.Len() > 0 {
3756		return invalidParams
3757	} else {
3758		return nil
3759	}
3760}
3761
3762func validateOpDeleteUserPoolInput(v *DeleteUserPoolInput) error {
3763	if v == nil {
3764		return nil
3765	}
3766	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserPoolInput"}
3767	if v.UserPoolId == nil {
3768		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3769	}
3770	if invalidParams.Len() > 0 {
3771		return invalidParams
3772	} else {
3773		return nil
3774	}
3775}
3776
3777func validateOpDescribeIdentityProviderInput(v *DescribeIdentityProviderInput) error {
3778	if v == nil {
3779		return nil
3780	}
3781	invalidParams := smithy.InvalidParamsError{Context: "DescribeIdentityProviderInput"}
3782	if v.UserPoolId == nil {
3783		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3784	}
3785	if v.ProviderName == nil {
3786		invalidParams.Add(smithy.NewErrParamRequired("ProviderName"))
3787	}
3788	if invalidParams.Len() > 0 {
3789		return invalidParams
3790	} else {
3791		return nil
3792	}
3793}
3794
3795func validateOpDescribeResourceServerInput(v *DescribeResourceServerInput) error {
3796	if v == nil {
3797		return nil
3798	}
3799	invalidParams := smithy.InvalidParamsError{Context: "DescribeResourceServerInput"}
3800	if v.UserPoolId == nil {
3801		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3802	}
3803	if v.Identifier == nil {
3804		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
3805	}
3806	if invalidParams.Len() > 0 {
3807		return invalidParams
3808	} else {
3809		return nil
3810	}
3811}
3812
3813func validateOpDescribeRiskConfigurationInput(v *DescribeRiskConfigurationInput) error {
3814	if v == nil {
3815		return nil
3816	}
3817	invalidParams := smithy.InvalidParamsError{Context: "DescribeRiskConfigurationInput"}
3818	if v.UserPoolId == nil {
3819		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3820	}
3821	if invalidParams.Len() > 0 {
3822		return invalidParams
3823	} else {
3824		return nil
3825	}
3826}
3827
3828func validateOpDescribeUserImportJobInput(v *DescribeUserImportJobInput) error {
3829	if v == nil {
3830		return nil
3831	}
3832	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserImportJobInput"}
3833	if v.UserPoolId == nil {
3834		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3835	}
3836	if v.JobId == nil {
3837		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
3838	}
3839	if invalidParams.Len() > 0 {
3840		return invalidParams
3841	} else {
3842		return nil
3843	}
3844}
3845
3846func validateOpDescribeUserPoolClientInput(v *DescribeUserPoolClientInput) error {
3847	if v == nil {
3848		return nil
3849	}
3850	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserPoolClientInput"}
3851	if v.UserPoolId == nil {
3852		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3853	}
3854	if v.ClientId == nil {
3855		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
3856	}
3857	if invalidParams.Len() > 0 {
3858		return invalidParams
3859	} else {
3860		return nil
3861	}
3862}
3863
3864func validateOpDescribeUserPoolDomainInput(v *DescribeUserPoolDomainInput) error {
3865	if v == nil {
3866		return nil
3867	}
3868	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserPoolDomainInput"}
3869	if v.Domain == nil {
3870		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
3871	}
3872	if invalidParams.Len() > 0 {
3873		return invalidParams
3874	} else {
3875		return nil
3876	}
3877}
3878
3879func validateOpDescribeUserPoolInput(v *DescribeUserPoolInput) error {
3880	if v == nil {
3881		return nil
3882	}
3883	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserPoolInput"}
3884	if v.UserPoolId == nil {
3885		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3886	}
3887	if invalidParams.Len() > 0 {
3888		return invalidParams
3889	} else {
3890		return nil
3891	}
3892}
3893
3894func validateOpForgetDeviceInput(v *ForgetDeviceInput) error {
3895	if v == nil {
3896		return nil
3897	}
3898	invalidParams := smithy.InvalidParamsError{Context: "ForgetDeviceInput"}
3899	if v.DeviceKey == nil {
3900		invalidParams.Add(smithy.NewErrParamRequired("DeviceKey"))
3901	}
3902	if invalidParams.Len() > 0 {
3903		return invalidParams
3904	} else {
3905		return nil
3906	}
3907}
3908
3909func validateOpForgotPasswordInput(v *ForgotPasswordInput) error {
3910	if v == nil {
3911		return nil
3912	}
3913	invalidParams := smithy.InvalidParamsError{Context: "ForgotPasswordInput"}
3914	if v.ClientId == nil {
3915		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
3916	}
3917	if v.Username == nil {
3918		invalidParams.Add(smithy.NewErrParamRequired("Username"))
3919	}
3920	if invalidParams.Len() > 0 {
3921		return invalidParams
3922	} else {
3923		return nil
3924	}
3925}
3926
3927func validateOpGetCSVHeaderInput(v *GetCSVHeaderInput) error {
3928	if v == nil {
3929		return nil
3930	}
3931	invalidParams := smithy.InvalidParamsError{Context: "GetCSVHeaderInput"}
3932	if v.UserPoolId == nil {
3933		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3934	}
3935	if invalidParams.Len() > 0 {
3936		return invalidParams
3937	} else {
3938		return nil
3939	}
3940}
3941
3942func validateOpGetDeviceInput(v *GetDeviceInput) error {
3943	if v == nil {
3944		return nil
3945	}
3946	invalidParams := smithy.InvalidParamsError{Context: "GetDeviceInput"}
3947	if v.DeviceKey == nil {
3948		invalidParams.Add(smithy.NewErrParamRequired("DeviceKey"))
3949	}
3950	if invalidParams.Len() > 0 {
3951		return invalidParams
3952	} else {
3953		return nil
3954	}
3955}
3956
3957func validateOpGetGroupInput(v *GetGroupInput) error {
3958	if v == nil {
3959		return nil
3960	}
3961	invalidParams := smithy.InvalidParamsError{Context: "GetGroupInput"}
3962	if v.GroupName == nil {
3963		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
3964	}
3965	if v.UserPoolId == nil {
3966		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3967	}
3968	if invalidParams.Len() > 0 {
3969		return invalidParams
3970	} else {
3971		return nil
3972	}
3973}
3974
3975func validateOpGetIdentityProviderByIdentifierInput(v *GetIdentityProviderByIdentifierInput) error {
3976	if v == nil {
3977		return nil
3978	}
3979	invalidParams := smithy.InvalidParamsError{Context: "GetIdentityProviderByIdentifierInput"}
3980	if v.UserPoolId == nil {
3981		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
3982	}
3983	if v.IdpIdentifier == nil {
3984		invalidParams.Add(smithy.NewErrParamRequired("IdpIdentifier"))
3985	}
3986	if invalidParams.Len() > 0 {
3987		return invalidParams
3988	} else {
3989		return nil
3990	}
3991}
3992
3993func validateOpGetSigningCertificateInput(v *GetSigningCertificateInput) error {
3994	if v == nil {
3995		return nil
3996	}
3997	invalidParams := smithy.InvalidParamsError{Context: "GetSigningCertificateInput"}
3998	if v.UserPoolId == nil {
3999		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4000	}
4001	if invalidParams.Len() > 0 {
4002		return invalidParams
4003	} else {
4004		return nil
4005	}
4006}
4007
4008func validateOpGetUICustomizationInput(v *GetUICustomizationInput) error {
4009	if v == nil {
4010		return nil
4011	}
4012	invalidParams := smithy.InvalidParamsError{Context: "GetUICustomizationInput"}
4013	if v.UserPoolId == nil {
4014		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4015	}
4016	if invalidParams.Len() > 0 {
4017		return invalidParams
4018	} else {
4019		return nil
4020	}
4021}
4022
4023func validateOpGetUserAttributeVerificationCodeInput(v *GetUserAttributeVerificationCodeInput) error {
4024	if v == nil {
4025		return nil
4026	}
4027	invalidParams := smithy.InvalidParamsError{Context: "GetUserAttributeVerificationCodeInput"}
4028	if v.AccessToken == nil {
4029		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
4030	}
4031	if v.AttributeName == nil {
4032		invalidParams.Add(smithy.NewErrParamRequired("AttributeName"))
4033	}
4034	if invalidParams.Len() > 0 {
4035		return invalidParams
4036	} else {
4037		return nil
4038	}
4039}
4040
4041func validateOpGetUserInput(v *GetUserInput) error {
4042	if v == nil {
4043		return nil
4044	}
4045	invalidParams := smithy.InvalidParamsError{Context: "GetUserInput"}
4046	if v.AccessToken == nil {
4047		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
4048	}
4049	if invalidParams.Len() > 0 {
4050		return invalidParams
4051	} else {
4052		return nil
4053	}
4054}
4055
4056func validateOpGetUserPoolMfaConfigInput(v *GetUserPoolMfaConfigInput) error {
4057	if v == nil {
4058		return nil
4059	}
4060	invalidParams := smithy.InvalidParamsError{Context: "GetUserPoolMfaConfigInput"}
4061	if v.UserPoolId == nil {
4062		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4063	}
4064	if invalidParams.Len() > 0 {
4065		return invalidParams
4066	} else {
4067		return nil
4068	}
4069}
4070
4071func validateOpGlobalSignOutInput(v *GlobalSignOutInput) error {
4072	if v == nil {
4073		return nil
4074	}
4075	invalidParams := smithy.InvalidParamsError{Context: "GlobalSignOutInput"}
4076	if v.AccessToken == nil {
4077		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
4078	}
4079	if invalidParams.Len() > 0 {
4080		return invalidParams
4081	} else {
4082		return nil
4083	}
4084}
4085
4086func validateOpInitiateAuthInput(v *InitiateAuthInput) error {
4087	if v == nil {
4088		return nil
4089	}
4090	invalidParams := smithy.InvalidParamsError{Context: "InitiateAuthInput"}
4091	if len(v.AuthFlow) == 0 {
4092		invalidParams.Add(smithy.NewErrParamRequired("AuthFlow"))
4093	}
4094	if v.ClientId == nil {
4095		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
4096	}
4097	if invalidParams.Len() > 0 {
4098		return invalidParams
4099	} else {
4100		return nil
4101	}
4102}
4103
4104func validateOpListDevicesInput(v *ListDevicesInput) error {
4105	if v == nil {
4106		return nil
4107	}
4108	invalidParams := smithy.InvalidParamsError{Context: "ListDevicesInput"}
4109	if v.AccessToken == nil {
4110		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
4111	}
4112	if invalidParams.Len() > 0 {
4113		return invalidParams
4114	} else {
4115		return nil
4116	}
4117}
4118
4119func validateOpListGroupsInput(v *ListGroupsInput) error {
4120	if v == nil {
4121		return nil
4122	}
4123	invalidParams := smithy.InvalidParamsError{Context: "ListGroupsInput"}
4124	if v.UserPoolId == nil {
4125		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4126	}
4127	if invalidParams.Len() > 0 {
4128		return invalidParams
4129	} else {
4130		return nil
4131	}
4132}
4133
4134func validateOpListIdentityProvidersInput(v *ListIdentityProvidersInput) error {
4135	if v == nil {
4136		return nil
4137	}
4138	invalidParams := smithy.InvalidParamsError{Context: "ListIdentityProvidersInput"}
4139	if v.UserPoolId == nil {
4140		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4141	}
4142	if invalidParams.Len() > 0 {
4143		return invalidParams
4144	} else {
4145		return nil
4146	}
4147}
4148
4149func validateOpListResourceServersInput(v *ListResourceServersInput) error {
4150	if v == nil {
4151		return nil
4152	}
4153	invalidParams := smithy.InvalidParamsError{Context: "ListResourceServersInput"}
4154	if v.UserPoolId == nil {
4155		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4156	}
4157	if invalidParams.Len() > 0 {
4158		return invalidParams
4159	} else {
4160		return nil
4161	}
4162}
4163
4164func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
4165	if v == nil {
4166		return nil
4167	}
4168	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
4169	if v.ResourceArn == nil {
4170		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
4171	}
4172	if invalidParams.Len() > 0 {
4173		return invalidParams
4174	} else {
4175		return nil
4176	}
4177}
4178
4179func validateOpListUserImportJobsInput(v *ListUserImportJobsInput) error {
4180	if v == nil {
4181		return nil
4182	}
4183	invalidParams := smithy.InvalidParamsError{Context: "ListUserImportJobsInput"}
4184	if v.UserPoolId == nil {
4185		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4186	}
4187	if invalidParams.Len() > 0 {
4188		return invalidParams
4189	} else {
4190		return nil
4191	}
4192}
4193
4194func validateOpListUserPoolClientsInput(v *ListUserPoolClientsInput) error {
4195	if v == nil {
4196		return nil
4197	}
4198	invalidParams := smithy.InvalidParamsError{Context: "ListUserPoolClientsInput"}
4199	if v.UserPoolId == nil {
4200		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4201	}
4202	if invalidParams.Len() > 0 {
4203		return invalidParams
4204	} else {
4205		return nil
4206	}
4207}
4208
4209func validateOpListUserPoolsInput(v *ListUserPoolsInput) error {
4210	if v == nil {
4211		return nil
4212	}
4213	invalidParams := smithy.InvalidParamsError{Context: "ListUserPoolsInput"}
4214	if invalidParams.Len() > 0 {
4215		return invalidParams
4216	} else {
4217		return nil
4218	}
4219}
4220
4221func validateOpListUsersInGroupInput(v *ListUsersInGroupInput) error {
4222	if v == nil {
4223		return nil
4224	}
4225	invalidParams := smithy.InvalidParamsError{Context: "ListUsersInGroupInput"}
4226	if v.UserPoolId == nil {
4227		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4228	}
4229	if v.GroupName == nil {
4230		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
4231	}
4232	if invalidParams.Len() > 0 {
4233		return invalidParams
4234	} else {
4235		return nil
4236	}
4237}
4238
4239func validateOpListUsersInput(v *ListUsersInput) error {
4240	if v == nil {
4241		return nil
4242	}
4243	invalidParams := smithy.InvalidParamsError{Context: "ListUsersInput"}
4244	if v.UserPoolId == nil {
4245		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4246	}
4247	if invalidParams.Len() > 0 {
4248		return invalidParams
4249	} else {
4250		return nil
4251	}
4252}
4253
4254func validateOpResendConfirmationCodeInput(v *ResendConfirmationCodeInput) error {
4255	if v == nil {
4256		return nil
4257	}
4258	invalidParams := smithy.InvalidParamsError{Context: "ResendConfirmationCodeInput"}
4259	if v.ClientId == nil {
4260		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
4261	}
4262	if v.Username == nil {
4263		invalidParams.Add(smithy.NewErrParamRequired("Username"))
4264	}
4265	if invalidParams.Len() > 0 {
4266		return invalidParams
4267	} else {
4268		return nil
4269	}
4270}
4271
4272func validateOpRespondToAuthChallengeInput(v *RespondToAuthChallengeInput) error {
4273	if v == nil {
4274		return nil
4275	}
4276	invalidParams := smithy.InvalidParamsError{Context: "RespondToAuthChallengeInput"}
4277	if v.ClientId == nil {
4278		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
4279	}
4280	if len(v.ChallengeName) == 0 {
4281		invalidParams.Add(smithy.NewErrParamRequired("ChallengeName"))
4282	}
4283	if invalidParams.Len() > 0 {
4284		return invalidParams
4285	} else {
4286		return nil
4287	}
4288}
4289
4290func validateOpRevokeTokenInput(v *RevokeTokenInput) error {
4291	if v == nil {
4292		return nil
4293	}
4294	invalidParams := smithy.InvalidParamsError{Context: "RevokeTokenInput"}
4295	if v.Token == nil {
4296		invalidParams.Add(smithy.NewErrParamRequired("Token"))
4297	}
4298	if v.ClientId == nil {
4299		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
4300	}
4301	if invalidParams.Len() > 0 {
4302		return invalidParams
4303	} else {
4304		return nil
4305	}
4306}
4307
4308func validateOpSetRiskConfigurationInput(v *SetRiskConfigurationInput) error {
4309	if v == nil {
4310		return nil
4311	}
4312	invalidParams := smithy.InvalidParamsError{Context: "SetRiskConfigurationInput"}
4313	if v.UserPoolId == nil {
4314		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4315	}
4316	if v.CompromisedCredentialsRiskConfiguration != nil {
4317		if err := validateCompromisedCredentialsRiskConfigurationType(v.CompromisedCredentialsRiskConfiguration); err != nil {
4318			invalidParams.AddNested("CompromisedCredentialsRiskConfiguration", err.(smithy.InvalidParamsError))
4319		}
4320	}
4321	if v.AccountTakeoverRiskConfiguration != nil {
4322		if err := validateAccountTakeoverRiskConfigurationType(v.AccountTakeoverRiskConfiguration); err != nil {
4323			invalidParams.AddNested("AccountTakeoverRiskConfiguration", err.(smithy.InvalidParamsError))
4324		}
4325	}
4326	if invalidParams.Len() > 0 {
4327		return invalidParams
4328	} else {
4329		return nil
4330	}
4331}
4332
4333func validateOpSetUICustomizationInput(v *SetUICustomizationInput) error {
4334	if v == nil {
4335		return nil
4336	}
4337	invalidParams := smithy.InvalidParamsError{Context: "SetUICustomizationInput"}
4338	if v.UserPoolId == nil {
4339		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4340	}
4341	if invalidParams.Len() > 0 {
4342		return invalidParams
4343	} else {
4344		return nil
4345	}
4346}
4347
4348func validateOpSetUserMFAPreferenceInput(v *SetUserMFAPreferenceInput) error {
4349	if v == nil {
4350		return nil
4351	}
4352	invalidParams := smithy.InvalidParamsError{Context: "SetUserMFAPreferenceInput"}
4353	if v.AccessToken == nil {
4354		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
4355	}
4356	if invalidParams.Len() > 0 {
4357		return invalidParams
4358	} else {
4359		return nil
4360	}
4361}
4362
4363func validateOpSetUserPoolMfaConfigInput(v *SetUserPoolMfaConfigInput) error {
4364	if v == nil {
4365		return nil
4366	}
4367	invalidParams := smithy.InvalidParamsError{Context: "SetUserPoolMfaConfigInput"}
4368	if v.UserPoolId == nil {
4369		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4370	}
4371	if v.SmsMfaConfiguration != nil {
4372		if err := validateSmsMfaConfigType(v.SmsMfaConfiguration); err != nil {
4373			invalidParams.AddNested("SmsMfaConfiguration", err.(smithy.InvalidParamsError))
4374		}
4375	}
4376	if invalidParams.Len() > 0 {
4377		return invalidParams
4378	} else {
4379		return nil
4380	}
4381}
4382
4383func validateOpSetUserSettingsInput(v *SetUserSettingsInput) error {
4384	if v == nil {
4385		return nil
4386	}
4387	invalidParams := smithy.InvalidParamsError{Context: "SetUserSettingsInput"}
4388	if v.AccessToken == nil {
4389		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
4390	}
4391	if v.MFAOptions == nil {
4392		invalidParams.Add(smithy.NewErrParamRequired("MFAOptions"))
4393	}
4394	if invalidParams.Len() > 0 {
4395		return invalidParams
4396	} else {
4397		return nil
4398	}
4399}
4400
4401func validateOpSignUpInput(v *SignUpInput) error {
4402	if v == nil {
4403		return nil
4404	}
4405	invalidParams := smithy.InvalidParamsError{Context: "SignUpInput"}
4406	if v.ClientId == nil {
4407		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
4408	}
4409	if v.Username == nil {
4410		invalidParams.Add(smithy.NewErrParamRequired("Username"))
4411	}
4412	if v.Password == nil {
4413		invalidParams.Add(smithy.NewErrParamRequired("Password"))
4414	}
4415	if v.UserAttributes != nil {
4416		if err := validateAttributeListType(v.UserAttributes); err != nil {
4417			invalidParams.AddNested("UserAttributes", err.(smithy.InvalidParamsError))
4418		}
4419	}
4420	if v.ValidationData != nil {
4421		if err := validateAttributeListType(v.ValidationData); err != nil {
4422			invalidParams.AddNested("ValidationData", err.(smithy.InvalidParamsError))
4423		}
4424	}
4425	if invalidParams.Len() > 0 {
4426		return invalidParams
4427	} else {
4428		return nil
4429	}
4430}
4431
4432func validateOpStartUserImportJobInput(v *StartUserImportJobInput) error {
4433	if v == nil {
4434		return nil
4435	}
4436	invalidParams := smithy.InvalidParamsError{Context: "StartUserImportJobInput"}
4437	if v.UserPoolId == nil {
4438		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4439	}
4440	if v.JobId == nil {
4441		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
4442	}
4443	if invalidParams.Len() > 0 {
4444		return invalidParams
4445	} else {
4446		return nil
4447	}
4448}
4449
4450func validateOpStopUserImportJobInput(v *StopUserImportJobInput) error {
4451	if v == nil {
4452		return nil
4453	}
4454	invalidParams := smithy.InvalidParamsError{Context: "StopUserImportJobInput"}
4455	if v.UserPoolId == nil {
4456		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4457	}
4458	if v.JobId == nil {
4459		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
4460	}
4461	if invalidParams.Len() > 0 {
4462		return invalidParams
4463	} else {
4464		return nil
4465	}
4466}
4467
4468func validateOpTagResourceInput(v *TagResourceInput) error {
4469	if v == nil {
4470		return nil
4471	}
4472	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
4473	if v.ResourceArn == nil {
4474		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
4475	}
4476	if v.Tags == nil {
4477		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
4478	}
4479	if invalidParams.Len() > 0 {
4480		return invalidParams
4481	} else {
4482		return nil
4483	}
4484}
4485
4486func validateOpUntagResourceInput(v *UntagResourceInput) error {
4487	if v == nil {
4488		return nil
4489	}
4490	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
4491	if v.ResourceArn == nil {
4492		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
4493	}
4494	if v.TagKeys == nil {
4495		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
4496	}
4497	if invalidParams.Len() > 0 {
4498		return invalidParams
4499	} else {
4500		return nil
4501	}
4502}
4503
4504func validateOpUpdateAuthEventFeedbackInput(v *UpdateAuthEventFeedbackInput) error {
4505	if v == nil {
4506		return nil
4507	}
4508	invalidParams := smithy.InvalidParamsError{Context: "UpdateAuthEventFeedbackInput"}
4509	if v.UserPoolId == nil {
4510		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4511	}
4512	if v.Username == nil {
4513		invalidParams.Add(smithy.NewErrParamRequired("Username"))
4514	}
4515	if v.EventId == nil {
4516		invalidParams.Add(smithy.NewErrParamRequired("EventId"))
4517	}
4518	if v.FeedbackToken == nil {
4519		invalidParams.Add(smithy.NewErrParamRequired("FeedbackToken"))
4520	}
4521	if len(v.FeedbackValue) == 0 {
4522		invalidParams.Add(smithy.NewErrParamRequired("FeedbackValue"))
4523	}
4524	if invalidParams.Len() > 0 {
4525		return invalidParams
4526	} else {
4527		return nil
4528	}
4529}
4530
4531func validateOpUpdateDeviceStatusInput(v *UpdateDeviceStatusInput) error {
4532	if v == nil {
4533		return nil
4534	}
4535	invalidParams := smithy.InvalidParamsError{Context: "UpdateDeviceStatusInput"}
4536	if v.AccessToken == nil {
4537		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
4538	}
4539	if v.DeviceKey == nil {
4540		invalidParams.Add(smithy.NewErrParamRequired("DeviceKey"))
4541	}
4542	if invalidParams.Len() > 0 {
4543		return invalidParams
4544	} else {
4545		return nil
4546	}
4547}
4548
4549func validateOpUpdateGroupInput(v *UpdateGroupInput) error {
4550	if v == nil {
4551		return nil
4552	}
4553	invalidParams := smithy.InvalidParamsError{Context: "UpdateGroupInput"}
4554	if v.GroupName == nil {
4555		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
4556	}
4557	if v.UserPoolId == nil {
4558		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4559	}
4560	if invalidParams.Len() > 0 {
4561		return invalidParams
4562	} else {
4563		return nil
4564	}
4565}
4566
4567func validateOpUpdateIdentityProviderInput(v *UpdateIdentityProviderInput) error {
4568	if v == nil {
4569		return nil
4570	}
4571	invalidParams := smithy.InvalidParamsError{Context: "UpdateIdentityProviderInput"}
4572	if v.UserPoolId == nil {
4573		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4574	}
4575	if v.ProviderName == nil {
4576		invalidParams.Add(smithy.NewErrParamRequired("ProviderName"))
4577	}
4578	if invalidParams.Len() > 0 {
4579		return invalidParams
4580	} else {
4581		return nil
4582	}
4583}
4584
4585func validateOpUpdateResourceServerInput(v *UpdateResourceServerInput) error {
4586	if v == nil {
4587		return nil
4588	}
4589	invalidParams := smithy.InvalidParamsError{Context: "UpdateResourceServerInput"}
4590	if v.UserPoolId == nil {
4591		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4592	}
4593	if v.Identifier == nil {
4594		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
4595	}
4596	if v.Name == nil {
4597		invalidParams.Add(smithy.NewErrParamRequired("Name"))
4598	}
4599	if v.Scopes != nil {
4600		if err := validateResourceServerScopeListType(v.Scopes); err != nil {
4601			invalidParams.AddNested("Scopes", err.(smithy.InvalidParamsError))
4602		}
4603	}
4604	if invalidParams.Len() > 0 {
4605		return invalidParams
4606	} else {
4607		return nil
4608	}
4609}
4610
4611func validateOpUpdateUserAttributesInput(v *UpdateUserAttributesInput) error {
4612	if v == nil {
4613		return nil
4614	}
4615	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserAttributesInput"}
4616	if v.UserAttributes == nil {
4617		invalidParams.Add(smithy.NewErrParamRequired("UserAttributes"))
4618	} else if v.UserAttributes != nil {
4619		if err := validateAttributeListType(v.UserAttributes); err != nil {
4620			invalidParams.AddNested("UserAttributes", err.(smithy.InvalidParamsError))
4621		}
4622	}
4623	if v.AccessToken == nil {
4624		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
4625	}
4626	if invalidParams.Len() > 0 {
4627		return invalidParams
4628	} else {
4629		return nil
4630	}
4631}
4632
4633func validateOpUpdateUserPoolClientInput(v *UpdateUserPoolClientInput) error {
4634	if v == nil {
4635		return nil
4636	}
4637	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserPoolClientInput"}
4638	if v.UserPoolId == nil {
4639		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4640	}
4641	if v.ClientId == nil {
4642		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
4643	}
4644	if invalidParams.Len() > 0 {
4645		return invalidParams
4646	} else {
4647		return nil
4648	}
4649}
4650
4651func validateOpUpdateUserPoolDomainInput(v *UpdateUserPoolDomainInput) error {
4652	if v == nil {
4653		return nil
4654	}
4655	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserPoolDomainInput"}
4656	if v.Domain == nil {
4657		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
4658	}
4659	if v.UserPoolId == nil {
4660		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4661	}
4662	if v.CustomDomainConfig == nil {
4663		invalidParams.Add(smithy.NewErrParamRequired("CustomDomainConfig"))
4664	} else if v.CustomDomainConfig != nil {
4665		if err := validateCustomDomainConfigType(v.CustomDomainConfig); err != nil {
4666			invalidParams.AddNested("CustomDomainConfig", err.(smithy.InvalidParamsError))
4667		}
4668	}
4669	if invalidParams.Len() > 0 {
4670		return invalidParams
4671	} else {
4672		return nil
4673	}
4674}
4675
4676func validateOpUpdateUserPoolInput(v *UpdateUserPoolInput) error {
4677	if v == nil {
4678		return nil
4679	}
4680	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserPoolInput"}
4681	if v.UserPoolId == nil {
4682		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
4683	}
4684	if v.LambdaConfig != nil {
4685		if err := validateLambdaConfigType(v.LambdaConfig); err != nil {
4686			invalidParams.AddNested("LambdaConfig", err.(smithy.InvalidParamsError))
4687		}
4688	}
4689	if v.SmsConfiguration != nil {
4690		if err := validateSmsConfigurationType(v.SmsConfiguration); err != nil {
4691			invalidParams.AddNested("SmsConfiguration", err.(smithy.InvalidParamsError))
4692		}
4693	}
4694	if v.UserPoolAddOns != nil {
4695		if err := validateUserPoolAddOnsType(v.UserPoolAddOns); err != nil {
4696			invalidParams.AddNested("UserPoolAddOns", err.(smithy.InvalidParamsError))
4697		}
4698	}
4699	if v.AccountRecoverySetting != nil {
4700		if err := validateAccountRecoverySettingType(v.AccountRecoverySetting); err != nil {
4701			invalidParams.AddNested("AccountRecoverySetting", err.(smithy.InvalidParamsError))
4702		}
4703	}
4704	if invalidParams.Len() > 0 {
4705		return invalidParams
4706	} else {
4707		return nil
4708	}
4709}
4710
4711func validateOpVerifySoftwareTokenInput(v *VerifySoftwareTokenInput) error {
4712	if v == nil {
4713		return nil
4714	}
4715	invalidParams := smithy.InvalidParamsError{Context: "VerifySoftwareTokenInput"}
4716	if v.UserCode == nil {
4717		invalidParams.Add(smithy.NewErrParamRequired("UserCode"))
4718	}
4719	if invalidParams.Len() > 0 {
4720		return invalidParams
4721	} else {
4722		return nil
4723	}
4724}
4725
4726func validateOpVerifyUserAttributeInput(v *VerifyUserAttributeInput) error {
4727	if v == nil {
4728		return nil
4729	}
4730	invalidParams := smithy.InvalidParamsError{Context: "VerifyUserAttributeInput"}
4731	if v.AccessToken == nil {
4732		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
4733	}
4734	if v.AttributeName == nil {
4735		invalidParams.Add(smithy.NewErrParamRequired("AttributeName"))
4736	}
4737	if v.Code == nil {
4738		invalidParams.Add(smithy.NewErrParamRequired("Code"))
4739	}
4740	if invalidParams.Len() > 0 {
4741		return invalidParams
4742	} else {
4743		return nil
4744	}
4745}
4746