1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package amplifybackend
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/amplifybackend/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCloneBackend struct {
14}
15
16func (*validateOpCloneBackend) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCloneBackend) 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.(*CloneBackendInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCloneBackendInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateBackendAPI struct {
34}
35
36func (*validateOpCreateBackendAPI) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateBackendAPI) 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.(*CreateBackendAPIInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateBackendAPIInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateBackendAuth struct {
54}
55
56func (*validateOpCreateBackendAuth) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateBackendAuth) 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.(*CreateBackendAuthInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateBackendAuthInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateBackendConfig struct {
74}
75
76func (*validateOpCreateBackendConfig) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateBackendConfig) 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.(*CreateBackendConfigInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateBackendConfigInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateBackend struct {
94}
95
96func (*validateOpCreateBackend) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateBackend) 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.(*CreateBackendInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateBackendInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateToken struct {
114}
115
116func (*validateOpCreateToken) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateToken) 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.(*CreateTokenInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateTokenInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDeleteBackendAPI struct {
134}
135
136func (*validateOpDeleteBackendAPI) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDeleteBackendAPI) 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.(*DeleteBackendAPIInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDeleteBackendAPIInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDeleteBackendAuth struct {
154}
155
156func (*validateOpDeleteBackendAuth) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDeleteBackendAuth) 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.(*DeleteBackendAuthInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDeleteBackendAuthInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDeleteBackend struct {
174}
175
176func (*validateOpDeleteBackend) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDeleteBackend) 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.(*DeleteBackendInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDeleteBackendInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDeleteToken struct {
194}
195
196func (*validateOpDeleteToken) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDeleteToken) 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.(*DeleteTokenInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDeleteTokenInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpGenerateBackendAPIModels struct {
214}
215
216func (*validateOpGenerateBackendAPIModels) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpGenerateBackendAPIModels) 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.(*GenerateBackendAPIModelsInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpGenerateBackendAPIModelsInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpGetBackendAPI struct {
234}
235
236func (*validateOpGetBackendAPI) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpGetBackendAPI) 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.(*GetBackendAPIInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpGetBackendAPIInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpGetBackendAPIModels struct {
254}
255
256func (*validateOpGetBackendAPIModels) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpGetBackendAPIModels) 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.(*GetBackendAPIModelsInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpGetBackendAPIModelsInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpGetBackendAuth struct {
274}
275
276func (*validateOpGetBackendAuth) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpGetBackendAuth) 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.(*GetBackendAuthInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpGetBackendAuthInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpGetBackend struct {
294}
295
296func (*validateOpGetBackend) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpGetBackend) 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.(*GetBackendInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpGetBackendInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpGetBackendJob struct {
314}
315
316func (*validateOpGetBackendJob) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpGetBackendJob) 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.(*GetBackendJobInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpGetBackendJobInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpGetToken struct {
334}
335
336func (*validateOpGetToken) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpGetToken) 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.(*GetTokenInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpGetTokenInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpListBackendJobs struct {
354}
355
356func (*validateOpListBackendJobs) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpListBackendJobs) 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.(*ListBackendJobsInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpListBackendJobsInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpRemoveAllBackends struct {
374}
375
376func (*validateOpRemoveAllBackends) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpRemoveAllBackends) 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.(*RemoveAllBackendsInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpRemoveAllBackendsInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpRemoveBackendConfig struct {
394}
395
396func (*validateOpRemoveBackendConfig) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpRemoveBackendConfig) 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.(*RemoveBackendConfigInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpRemoveBackendConfigInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpUpdateBackendAPI struct {
414}
415
416func (*validateOpUpdateBackendAPI) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpUpdateBackendAPI) 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.(*UpdateBackendAPIInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpUpdateBackendAPIInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpUpdateBackendAuth struct {
434}
435
436func (*validateOpUpdateBackendAuth) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpUpdateBackendAuth) 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.(*UpdateBackendAuthInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpUpdateBackendAuthInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpUpdateBackendConfig struct {
454}
455
456func (*validateOpUpdateBackendConfig) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpUpdateBackendConfig) 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.(*UpdateBackendConfigInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpUpdateBackendConfigInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpUpdateBackendJob struct {
474}
475
476func (*validateOpUpdateBackendJob) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpUpdateBackendJob) 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.(*UpdateBackendJobInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpUpdateBackendJobInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493func addOpCloneBackendValidationMiddleware(stack *middleware.Stack) error {
494	return stack.Initialize.Add(&validateOpCloneBackend{}, middleware.After)
495}
496
497func addOpCreateBackendAPIValidationMiddleware(stack *middleware.Stack) error {
498	return stack.Initialize.Add(&validateOpCreateBackendAPI{}, middleware.After)
499}
500
501func addOpCreateBackendAuthValidationMiddleware(stack *middleware.Stack) error {
502	return stack.Initialize.Add(&validateOpCreateBackendAuth{}, middleware.After)
503}
504
505func addOpCreateBackendConfigValidationMiddleware(stack *middleware.Stack) error {
506	return stack.Initialize.Add(&validateOpCreateBackendConfig{}, middleware.After)
507}
508
509func addOpCreateBackendValidationMiddleware(stack *middleware.Stack) error {
510	return stack.Initialize.Add(&validateOpCreateBackend{}, middleware.After)
511}
512
513func addOpCreateTokenValidationMiddleware(stack *middleware.Stack) error {
514	return stack.Initialize.Add(&validateOpCreateToken{}, middleware.After)
515}
516
517func addOpDeleteBackendAPIValidationMiddleware(stack *middleware.Stack) error {
518	return stack.Initialize.Add(&validateOpDeleteBackendAPI{}, middleware.After)
519}
520
521func addOpDeleteBackendAuthValidationMiddleware(stack *middleware.Stack) error {
522	return stack.Initialize.Add(&validateOpDeleteBackendAuth{}, middleware.After)
523}
524
525func addOpDeleteBackendValidationMiddleware(stack *middleware.Stack) error {
526	return stack.Initialize.Add(&validateOpDeleteBackend{}, middleware.After)
527}
528
529func addOpDeleteTokenValidationMiddleware(stack *middleware.Stack) error {
530	return stack.Initialize.Add(&validateOpDeleteToken{}, middleware.After)
531}
532
533func addOpGenerateBackendAPIModelsValidationMiddleware(stack *middleware.Stack) error {
534	return stack.Initialize.Add(&validateOpGenerateBackendAPIModels{}, middleware.After)
535}
536
537func addOpGetBackendAPIValidationMiddleware(stack *middleware.Stack) error {
538	return stack.Initialize.Add(&validateOpGetBackendAPI{}, middleware.After)
539}
540
541func addOpGetBackendAPIModelsValidationMiddleware(stack *middleware.Stack) error {
542	return stack.Initialize.Add(&validateOpGetBackendAPIModels{}, middleware.After)
543}
544
545func addOpGetBackendAuthValidationMiddleware(stack *middleware.Stack) error {
546	return stack.Initialize.Add(&validateOpGetBackendAuth{}, middleware.After)
547}
548
549func addOpGetBackendValidationMiddleware(stack *middleware.Stack) error {
550	return stack.Initialize.Add(&validateOpGetBackend{}, middleware.After)
551}
552
553func addOpGetBackendJobValidationMiddleware(stack *middleware.Stack) error {
554	return stack.Initialize.Add(&validateOpGetBackendJob{}, middleware.After)
555}
556
557func addOpGetTokenValidationMiddleware(stack *middleware.Stack) error {
558	return stack.Initialize.Add(&validateOpGetToken{}, middleware.After)
559}
560
561func addOpListBackendJobsValidationMiddleware(stack *middleware.Stack) error {
562	return stack.Initialize.Add(&validateOpListBackendJobs{}, middleware.After)
563}
564
565func addOpRemoveAllBackendsValidationMiddleware(stack *middleware.Stack) error {
566	return stack.Initialize.Add(&validateOpRemoveAllBackends{}, middleware.After)
567}
568
569func addOpRemoveBackendConfigValidationMiddleware(stack *middleware.Stack) error {
570	return stack.Initialize.Add(&validateOpRemoveBackendConfig{}, middleware.After)
571}
572
573func addOpUpdateBackendAPIValidationMiddleware(stack *middleware.Stack) error {
574	return stack.Initialize.Add(&validateOpUpdateBackendAPI{}, middleware.After)
575}
576
577func addOpUpdateBackendAuthValidationMiddleware(stack *middleware.Stack) error {
578	return stack.Initialize.Add(&validateOpUpdateBackendAuth{}, middleware.After)
579}
580
581func addOpUpdateBackendConfigValidationMiddleware(stack *middleware.Stack) error {
582	return stack.Initialize.Add(&validateOpUpdateBackendConfig{}, middleware.After)
583}
584
585func addOpUpdateBackendJobValidationMiddleware(stack *middleware.Stack) error {
586	return stack.Initialize.Add(&validateOpUpdateBackendJob{}, middleware.After)
587}
588
589func validateCreateBackendAuthForgotPasswordConfig(v *types.CreateBackendAuthForgotPasswordConfig) error {
590	if v == nil {
591		return nil
592	}
593	invalidParams := smithy.InvalidParamsError{Context: "CreateBackendAuthForgotPasswordConfig"}
594	if len(v.DeliveryMethod) == 0 {
595		invalidParams.Add(smithy.NewErrParamRequired("DeliveryMethod"))
596	}
597	if invalidParams.Len() > 0 {
598		return invalidParams
599	} else {
600		return nil
601	}
602}
603
604func validateCreateBackendAuthIdentityPoolConfig(v *types.CreateBackendAuthIdentityPoolConfig) error {
605	if v == nil {
606		return nil
607	}
608	invalidParams := smithy.InvalidParamsError{Context: "CreateBackendAuthIdentityPoolConfig"}
609	if v.IdentityPoolName == nil {
610		invalidParams.Add(smithy.NewErrParamRequired("IdentityPoolName"))
611	}
612	if invalidParams.Len() > 0 {
613		return invalidParams
614	} else {
615		return nil
616	}
617}
618
619func validateCreateBackendAuthMFAConfig(v *types.CreateBackendAuthMFAConfig) error {
620	if v == nil {
621		return nil
622	}
623	invalidParams := smithy.InvalidParamsError{Context: "CreateBackendAuthMFAConfig"}
624	if len(v.MFAMode) == 0 {
625		invalidParams.Add(smithy.NewErrParamRequired("MFAMode"))
626	}
627	if invalidParams.Len() > 0 {
628		return invalidParams
629	} else {
630		return nil
631	}
632}
633
634func validateCreateBackendAuthOAuthConfig(v *types.CreateBackendAuthOAuthConfig) error {
635	if v == nil {
636		return nil
637	}
638	invalidParams := smithy.InvalidParamsError{Context: "CreateBackendAuthOAuthConfig"}
639	if len(v.OAuthGrantType) == 0 {
640		invalidParams.Add(smithy.NewErrParamRequired("OAuthGrantType"))
641	}
642	if v.OAuthScopes == nil {
643		invalidParams.Add(smithy.NewErrParamRequired("OAuthScopes"))
644	}
645	if v.RedirectSignInURIs == nil {
646		invalidParams.Add(smithy.NewErrParamRequired("RedirectSignInURIs"))
647	}
648	if v.RedirectSignOutURIs == nil {
649		invalidParams.Add(smithy.NewErrParamRequired("RedirectSignOutURIs"))
650	}
651	if invalidParams.Len() > 0 {
652		return invalidParams
653	} else {
654		return nil
655	}
656}
657
658func validateCreateBackendAuthPasswordPolicyConfig(v *types.CreateBackendAuthPasswordPolicyConfig) error {
659	if v == nil {
660		return nil
661	}
662	invalidParams := smithy.InvalidParamsError{Context: "CreateBackendAuthPasswordPolicyConfig"}
663	if invalidParams.Len() > 0 {
664		return invalidParams
665	} else {
666		return nil
667	}
668}
669
670func validateCreateBackendAuthResourceConfig(v *types.CreateBackendAuthResourceConfig) error {
671	if v == nil {
672		return nil
673	}
674	invalidParams := smithy.InvalidParamsError{Context: "CreateBackendAuthResourceConfig"}
675	if len(v.AuthResources) == 0 {
676		invalidParams.Add(smithy.NewErrParamRequired("AuthResources"))
677	}
678	if v.IdentityPoolConfigs != nil {
679		if err := validateCreateBackendAuthIdentityPoolConfig(v.IdentityPoolConfigs); err != nil {
680			invalidParams.AddNested("IdentityPoolConfigs", err.(smithy.InvalidParamsError))
681		}
682	}
683	if len(v.Service) == 0 {
684		invalidParams.Add(smithy.NewErrParamRequired("Service"))
685	}
686	if v.UserPoolConfigs == nil {
687		invalidParams.Add(smithy.NewErrParamRequired("UserPoolConfigs"))
688	} else if v.UserPoolConfigs != nil {
689		if err := validateCreateBackendAuthUserPoolConfig(v.UserPoolConfigs); err != nil {
690			invalidParams.AddNested("UserPoolConfigs", err.(smithy.InvalidParamsError))
691		}
692	}
693	if invalidParams.Len() > 0 {
694		return invalidParams
695	} else {
696		return nil
697	}
698}
699
700func validateCreateBackendAuthUserPoolConfig(v *types.CreateBackendAuthUserPoolConfig) error {
701	if v == nil {
702		return nil
703	}
704	invalidParams := smithy.InvalidParamsError{Context: "CreateBackendAuthUserPoolConfig"}
705	if v.ForgotPassword != nil {
706		if err := validateCreateBackendAuthForgotPasswordConfig(v.ForgotPassword); err != nil {
707			invalidParams.AddNested("ForgotPassword", err.(smithy.InvalidParamsError))
708		}
709	}
710	if v.Mfa != nil {
711		if err := validateCreateBackendAuthMFAConfig(v.Mfa); err != nil {
712			invalidParams.AddNested("Mfa", err.(smithy.InvalidParamsError))
713		}
714	}
715	if v.OAuth != nil {
716		if err := validateCreateBackendAuthOAuthConfig(v.OAuth); err != nil {
717			invalidParams.AddNested("OAuth", err.(smithy.InvalidParamsError))
718		}
719	}
720	if v.PasswordPolicy != nil {
721		if err := validateCreateBackendAuthPasswordPolicyConfig(v.PasswordPolicy); err != nil {
722			invalidParams.AddNested("PasswordPolicy", err.(smithy.InvalidParamsError))
723		}
724	}
725	if v.RequiredSignUpAttributes == nil {
726		invalidParams.Add(smithy.NewErrParamRequired("RequiredSignUpAttributes"))
727	}
728	if len(v.SignInMethod) == 0 {
729		invalidParams.Add(smithy.NewErrParamRequired("SignInMethod"))
730	}
731	if v.UserPoolName == nil {
732		invalidParams.Add(smithy.NewErrParamRequired("UserPoolName"))
733	}
734	if invalidParams.Len() > 0 {
735		return invalidParams
736	} else {
737		return nil
738	}
739}
740
741func validateUpdateBackendAuthResourceConfig(v *types.UpdateBackendAuthResourceConfig) error {
742	if v == nil {
743		return nil
744	}
745	invalidParams := smithy.InvalidParamsError{Context: "UpdateBackendAuthResourceConfig"}
746	if len(v.AuthResources) == 0 {
747		invalidParams.Add(smithy.NewErrParamRequired("AuthResources"))
748	}
749	if len(v.Service) == 0 {
750		invalidParams.Add(smithy.NewErrParamRequired("Service"))
751	}
752	if v.UserPoolConfigs == nil {
753		invalidParams.Add(smithy.NewErrParamRequired("UserPoolConfigs"))
754	}
755	if invalidParams.Len() > 0 {
756		return invalidParams
757	} else {
758		return nil
759	}
760}
761
762func validateOpCloneBackendInput(v *CloneBackendInput) error {
763	if v == nil {
764		return nil
765	}
766	invalidParams := smithy.InvalidParamsError{Context: "CloneBackendInput"}
767	if v.AppId == nil {
768		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
769	}
770	if v.BackendEnvironmentName == nil {
771		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
772	}
773	if v.TargetEnvironmentName == nil {
774		invalidParams.Add(smithy.NewErrParamRequired("TargetEnvironmentName"))
775	}
776	if invalidParams.Len() > 0 {
777		return invalidParams
778	} else {
779		return nil
780	}
781}
782
783func validateOpCreateBackendAPIInput(v *CreateBackendAPIInput) error {
784	if v == nil {
785		return nil
786	}
787	invalidParams := smithy.InvalidParamsError{Context: "CreateBackendAPIInput"}
788	if v.AppId == nil {
789		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
790	}
791	if v.BackendEnvironmentName == nil {
792		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
793	}
794	if v.ResourceConfig == nil {
795		invalidParams.Add(smithy.NewErrParamRequired("ResourceConfig"))
796	}
797	if v.ResourceName == nil {
798		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
799	}
800	if invalidParams.Len() > 0 {
801		return invalidParams
802	} else {
803		return nil
804	}
805}
806
807func validateOpCreateBackendAuthInput(v *CreateBackendAuthInput) error {
808	if v == nil {
809		return nil
810	}
811	invalidParams := smithy.InvalidParamsError{Context: "CreateBackendAuthInput"}
812	if v.AppId == nil {
813		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
814	}
815	if v.BackendEnvironmentName == nil {
816		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
817	}
818	if v.ResourceConfig == nil {
819		invalidParams.Add(smithy.NewErrParamRequired("ResourceConfig"))
820	} else if v.ResourceConfig != nil {
821		if err := validateCreateBackendAuthResourceConfig(v.ResourceConfig); err != nil {
822			invalidParams.AddNested("ResourceConfig", err.(smithy.InvalidParamsError))
823		}
824	}
825	if v.ResourceName == nil {
826		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
827	}
828	if invalidParams.Len() > 0 {
829		return invalidParams
830	} else {
831		return nil
832	}
833}
834
835func validateOpCreateBackendConfigInput(v *CreateBackendConfigInput) error {
836	if v == nil {
837		return nil
838	}
839	invalidParams := smithy.InvalidParamsError{Context: "CreateBackendConfigInput"}
840	if v.AppId == nil {
841		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
842	}
843	if invalidParams.Len() > 0 {
844		return invalidParams
845	} else {
846		return nil
847	}
848}
849
850func validateOpCreateBackendInput(v *CreateBackendInput) error {
851	if v == nil {
852		return nil
853	}
854	invalidParams := smithy.InvalidParamsError{Context: "CreateBackendInput"}
855	if v.AppId == nil {
856		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
857	}
858	if v.AppName == nil {
859		invalidParams.Add(smithy.NewErrParamRequired("AppName"))
860	}
861	if v.BackendEnvironmentName == nil {
862		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
863	}
864	if invalidParams.Len() > 0 {
865		return invalidParams
866	} else {
867		return nil
868	}
869}
870
871func validateOpCreateTokenInput(v *CreateTokenInput) error {
872	if v == nil {
873		return nil
874	}
875	invalidParams := smithy.InvalidParamsError{Context: "CreateTokenInput"}
876	if v.AppId == nil {
877		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
878	}
879	if invalidParams.Len() > 0 {
880		return invalidParams
881	} else {
882		return nil
883	}
884}
885
886func validateOpDeleteBackendAPIInput(v *DeleteBackendAPIInput) error {
887	if v == nil {
888		return nil
889	}
890	invalidParams := smithy.InvalidParamsError{Context: "DeleteBackendAPIInput"}
891	if v.AppId == nil {
892		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
893	}
894	if v.BackendEnvironmentName == nil {
895		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
896	}
897	if v.ResourceName == nil {
898		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
899	}
900	if invalidParams.Len() > 0 {
901		return invalidParams
902	} else {
903		return nil
904	}
905}
906
907func validateOpDeleteBackendAuthInput(v *DeleteBackendAuthInput) error {
908	if v == nil {
909		return nil
910	}
911	invalidParams := smithy.InvalidParamsError{Context: "DeleteBackendAuthInput"}
912	if v.AppId == nil {
913		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
914	}
915	if v.BackendEnvironmentName == nil {
916		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
917	}
918	if v.ResourceName == nil {
919		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
920	}
921	if invalidParams.Len() > 0 {
922		return invalidParams
923	} else {
924		return nil
925	}
926}
927
928func validateOpDeleteBackendInput(v *DeleteBackendInput) error {
929	if v == nil {
930		return nil
931	}
932	invalidParams := smithy.InvalidParamsError{Context: "DeleteBackendInput"}
933	if v.AppId == nil {
934		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
935	}
936	if v.BackendEnvironmentName == nil {
937		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
938	}
939	if invalidParams.Len() > 0 {
940		return invalidParams
941	} else {
942		return nil
943	}
944}
945
946func validateOpDeleteTokenInput(v *DeleteTokenInput) error {
947	if v == nil {
948		return nil
949	}
950	invalidParams := smithy.InvalidParamsError{Context: "DeleteTokenInput"}
951	if v.AppId == nil {
952		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
953	}
954	if v.SessionId == nil {
955		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
956	}
957	if invalidParams.Len() > 0 {
958		return invalidParams
959	} else {
960		return nil
961	}
962}
963
964func validateOpGenerateBackendAPIModelsInput(v *GenerateBackendAPIModelsInput) error {
965	if v == nil {
966		return nil
967	}
968	invalidParams := smithy.InvalidParamsError{Context: "GenerateBackendAPIModelsInput"}
969	if v.AppId == nil {
970		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
971	}
972	if v.BackendEnvironmentName == nil {
973		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
974	}
975	if v.ResourceName == nil {
976		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
977	}
978	if invalidParams.Len() > 0 {
979		return invalidParams
980	} else {
981		return nil
982	}
983}
984
985func validateOpGetBackendAPIInput(v *GetBackendAPIInput) error {
986	if v == nil {
987		return nil
988	}
989	invalidParams := smithy.InvalidParamsError{Context: "GetBackendAPIInput"}
990	if v.AppId == nil {
991		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
992	}
993	if v.BackendEnvironmentName == nil {
994		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
995	}
996	if v.ResourceName == nil {
997		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
998	}
999	if invalidParams.Len() > 0 {
1000		return invalidParams
1001	} else {
1002		return nil
1003	}
1004}
1005
1006func validateOpGetBackendAPIModelsInput(v *GetBackendAPIModelsInput) error {
1007	if v == nil {
1008		return nil
1009	}
1010	invalidParams := smithy.InvalidParamsError{Context: "GetBackendAPIModelsInput"}
1011	if v.AppId == nil {
1012		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1013	}
1014	if v.BackendEnvironmentName == nil {
1015		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
1016	}
1017	if v.ResourceName == nil {
1018		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
1019	}
1020	if invalidParams.Len() > 0 {
1021		return invalidParams
1022	} else {
1023		return nil
1024	}
1025}
1026
1027func validateOpGetBackendAuthInput(v *GetBackendAuthInput) error {
1028	if v == nil {
1029		return nil
1030	}
1031	invalidParams := smithy.InvalidParamsError{Context: "GetBackendAuthInput"}
1032	if v.AppId == nil {
1033		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1034	}
1035	if v.BackendEnvironmentName == nil {
1036		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
1037	}
1038	if v.ResourceName == nil {
1039		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
1040	}
1041	if invalidParams.Len() > 0 {
1042		return invalidParams
1043	} else {
1044		return nil
1045	}
1046}
1047
1048func validateOpGetBackendInput(v *GetBackendInput) error {
1049	if v == nil {
1050		return nil
1051	}
1052	invalidParams := smithy.InvalidParamsError{Context: "GetBackendInput"}
1053	if v.AppId == nil {
1054		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1055	}
1056	if invalidParams.Len() > 0 {
1057		return invalidParams
1058	} else {
1059		return nil
1060	}
1061}
1062
1063func validateOpGetBackendJobInput(v *GetBackendJobInput) error {
1064	if v == nil {
1065		return nil
1066	}
1067	invalidParams := smithy.InvalidParamsError{Context: "GetBackendJobInput"}
1068	if v.AppId == nil {
1069		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1070	}
1071	if v.BackendEnvironmentName == nil {
1072		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
1073	}
1074	if v.JobId == nil {
1075		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1076	}
1077	if invalidParams.Len() > 0 {
1078		return invalidParams
1079	} else {
1080		return nil
1081	}
1082}
1083
1084func validateOpGetTokenInput(v *GetTokenInput) error {
1085	if v == nil {
1086		return nil
1087	}
1088	invalidParams := smithy.InvalidParamsError{Context: "GetTokenInput"}
1089	if v.AppId == nil {
1090		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1091	}
1092	if v.SessionId == nil {
1093		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
1094	}
1095	if invalidParams.Len() > 0 {
1096		return invalidParams
1097	} else {
1098		return nil
1099	}
1100}
1101
1102func validateOpListBackendJobsInput(v *ListBackendJobsInput) error {
1103	if v == nil {
1104		return nil
1105	}
1106	invalidParams := smithy.InvalidParamsError{Context: "ListBackendJobsInput"}
1107	if v.AppId == nil {
1108		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1109	}
1110	if v.BackendEnvironmentName == nil {
1111		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
1112	}
1113	if invalidParams.Len() > 0 {
1114		return invalidParams
1115	} else {
1116		return nil
1117	}
1118}
1119
1120func validateOpRemoveAllBackendsInput(v *RemoveAllBackendsInput) error {
1121	if v == nil {
1122		return nil
1123	}
1124	invalidParams := smithy.InvalidParamsError{Context: "RemoveAllBackendsInput"}
1125	if v.AppId == nil {
1126		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1127	}
1128	if invalidParams.Len() > 0 {
1129		return invalidParams
1130	} else {
1131		return nil
1132	}
1133}
1134
1135func validateOpRemoveBackendConfigInput(v *RemoveBackendConfigInput) error {
1136	if v == nil {
1137		return nil
1138	}
1139	invalidParams := smithy.InvalidParamsError{Context: "RemoveBackendConfigInput"}
1140	if v.AppId == nil {
1141		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1142	}
1143	if invalidParams.Len() > 0 {
1144		return invalidParams
1145	} else {
1146		return nil
1147	}
1148}
1149
1150func validateOpUpdateBackendAPIInput(v *UpdateBackendAPIInput) error {
1151	if v == nil {
1152		return nil
1153	}
1154	invalidParams := smithy.InvalidParamsError{Context: "UpdateBackendAPIInput"}
1155	if v.AppId == nil {
1156		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1157	}
1158	if v.BackendEnvironmentName == nil {
1159		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
1160	}
1161	if v.ResourceName == nil {
1162		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
1163	}
1164	if invalidParams.Len() > 0 {
1165		return invalidParams
1166	} else {
1167		return nil
1168	}
1169}
1170
1171func validateOpUpdateBackendAuthInput(v *UpdateBackendAuthInput) error {
1172	if v == nil {
1173		return nil
1174	}
1175	invalidParams := smithy.InvalidParamsError{Context: "UpdateBackendAuthInput"}
1176	if v.AppId == nil {
1177		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1178	}
1179	if v.BackendEnvironmentName == nil {
1180		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
1181	}
1182	if v.ResourceConfig == nil {
1183		invalidParams.Add(smithy.NewErrParamRequired("ResourceConfig"))
1184	} else if v.ResourceConfig != nil {
1185		if err := validateUpdateBackendAuthResourceConfig(v.ResourceConfig); err != nil {
1186			invalidParams.AddNested("ResourceConfig", err.(smithy.InvalidParamsError))
1187		}
1188	}
1189	if v.ResourceName == nil {
1190		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
1191	}
1192	if invalidParams.Len() > 0 {
1193		return invalidParams
1194	} else {
1195		return nil
1196	}
1197}
1198
1199func validateOpUpdateBackendConfigInput(v *UpdateBackendConfigInput) error {
1200	if v == nil {
1201		return nil
1202	}
1203	invalidParams := smithy.InvalidParamsError{Context: "UpdateBackendConfigInput"}
1204	if v.AppId == nil {
1205		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1206	}
1207	if invalidParams.Len() > 0 {
1208		return invalidParams
1209	} else {
1210		return nil
1211	}
1212}
1213
1214func validateOpUpdateBackendJobInput(v *UpdateBackendJobInput) error {
1215	if v == nil {
1216		return nil
1217	}
1218	invalidParams := smithy.InvalidParamsError{Context: "UpdateBackendJobInput"}
1219	if v.AppId == nil {
1220		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1221	}
1222	if v.BackendEnvironmentName == nil {
1223		invalidParams.Add(smithy.NewErrParamRequired("BackendEnvironmentName"))
1224	}
1225	if v.JobId == nil {
1226		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1227	}
1228	if invalidParams.Len() > 0 {
1229		return invalidParams
1230	} else {
1231		return nil
1232	}
1233}
1234