1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package amplify
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/amplify/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCreateApp struct {
14}
15
16func (*validateOpCreateApp) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCreateApp) 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.(*CreateAppInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCreateAppInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateBackendEnvironment struct {
34}
35
36func (*validateOpCreateBackendEnvironment) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateBackendEnvironment) 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.(*CreateBackendEnvironmentInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateBackendEnvironmentInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateBranch struct {
54}
55
56func (*validateOpCreateBranch) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateBranch) 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.(*CreateBranchInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateBranchInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateDeployment struct {
74}
75
76func (*validateOpCreateDeployment) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateDeployment) 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.(*CreateDeploymentInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateDeploymentInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateDomainAssociation struct {
94}
95
96func (*validateOpCreateDomainAssociation) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateDomainAssociation) 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.(*CreateDomainAssociationInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateDomainAssociationInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateWebhook struct {
114}
115
116func (*validateOpCreateWebhook) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateWebhook) 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.(*CreateWebhookInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateWebhookInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDeleteApp struct {
134}
135
136func (*validateOpDeleteApp) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDeleteApp) 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.(*DeleteAppInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDeleteAppInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDeleteBackendEnvironment struct {
154}
155
156func (*validateOpDeleteBackendEnvironment) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDeleteBackendEnvironment) 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.(*DeleteBackendEnvironmentInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDeleteBackendEnvironmentInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDeleteBranch struct {
174}
175
176func (*validateOpDeleteBranch) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDeleteBranch) 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.(*DeleteBranchInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDeleteBranchInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDeleteDomainAssociation struct {
194}
195
196func (*validateOpDeleteDomainAssociation) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDeleteDomainAssociation) 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.(*DeleteDomainAssociationInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDeleteDomainAssociationInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpDeleteJob struct {
214}
215
216func (*validateOpDeleteJob) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpDeleteJob) 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.(*DeleteJobInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpDeleteJobInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDeleteWebhook struct {
234}
235
236func (*validateOpDeleteWebhook) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDeleteWebhook) 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.(*DeleteWebhookInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDeleteWebhookInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpGenerateAccessLogs struct {
254}
255
256func (*validateOpGenerateAccessLogs) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpGenerateAccessLogs) 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.(*GenerateAccessLogsInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpGenerateAccessLogsInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpGetApp struct {
274}
275
276func (*validateOpGetApp) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpGetApp) 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.(*GetAppInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpGetAppInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpGetArtifactUrl struct {
294}
295
296func (*validateOpGetArtifactUrl) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpGetArtifactUrl) 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.(*GetArtifactUrlInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpGetArtifactUrlInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpGetBackendEnvironment struct {
314}
315
316func (*validateOpGetBackendEnvironment) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpGetBackendEnvironment) 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.(*GetBackendEnvironmentInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpGetBackendEnvironmentInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpGetBranch struct {
334}
335
336func (*validateOpGetBranch) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpGetBranch) 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.(*GetBranchInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpGetBranchInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpGetDomainAssociation struct {
354}
355
356func (*validateOpGetDomainAssociation) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpGetDomainAssociation) 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.(*GetDomainAssociationInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpGetDomainAssociationInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpGetJob struct {
374}
375
376func (*validateOpGetJob) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpGetJob) 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.(*GetJobInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpGetJobInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpGetWebhook struct {
394}
395
396func (*validateOpGetWebhook) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpGetWebhook) 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.(*GetWebhookInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpGetWebhookInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpListArtifacts struct {
414}
415
416func (*validateOpListArtifacts) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpListArtifacts) 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.(*ListArtifactsInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpListArtifactsInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpListBackendEnvironments struct {
434}
435
436func (*validateOpListBackendEnvironments) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpListBackendEnvironments) 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.(*ListBackendEnvironmentsInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpListBackendEnvironmentsInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpListBranches struct {
454}
455
456func (*validateOpListBranches) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpListBranches) 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.(*ListBranchesInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpListBranchesInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpListDomainAssociations struct {
474}
475
476func (*validateOpListDomainAssociations) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpListDomainAssociations) 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.(*ListDomainAssociationsInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpListDomainAssociationsInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpListJobs struct {
494}
495
496func (*validateOpListJobs) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpListJobs) 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.(*ListJobsInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpListJobsInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpListTagsForResource struct {
514}
515
516func (*validateOpListTagsForResource) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpListTagsForResourceInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpListWebhooks struct {
534}
535
536func (*validateOpListWebhooks) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpListWebhooks) 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.(*ListWebhooksInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpListWebhooksInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpStartDeployment struct {
554}
555
556func (*validateOpStartDeployment) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpStartDeployment) 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.(*StartDeploymentInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpStartDeploymentInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpStartJob struct {
574}
575
576func (*validateOpStartJob) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpStartJob) 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.(*StartJobInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpStartJobInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpStopJob struct {
594}
595
596func (*validateOpStopJob) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpStopJob) 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.(*StopJobInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpStopJobInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpTagResource struct {
614}
615
616func (*validateOpTagResource) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpTagResource) 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.(*TagResourceInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpTagResourceInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpUntagResource struct {
634}
635
636func (*validateOpUntagResource) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpUntagResource) 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.(*UntagResourceInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpUntagResourceInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpUpdateApp struct {
654}
655
656func (*validateOpUpdateApp) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpUpdateApp) 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.(*UpdateAppInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpUpdateAppInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpUpdateBranch struct {
674}
675
676func (*validateOpUpdateBranch) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpUpdateBranch) 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.(*UpdateBranchInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpUpdateBranchInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpUpdateDomainAssociation struct {
694}
695
696func (*validateOpUpdateDomainAssociation) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpUpdateDomainAssociation) 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.(*UpdateDomainAssociationInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpUpdateDomainAssociationInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpUpdateWebhook struct {
714}
715
716func (*validateOpUpdateWebhook) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpUpdateWebhook) 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.(*UpdateWebhookInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpUpdateWebhookInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733func addOpCreateAppValidationMiddleware(stack *middleware.Stack) error {
734	return stack.Initialize.Add(&validateOpCreateApp{}, middleware.After)
735}
736
737func addOpCreateBackendEnvironmentValidationMiddleware(stack *middleware.Stack) error {
738	return stack.Initialize.Add(&validateOpCreateBackendEnvironment{}, middleware.After)
739}
740
741func addOpCreateBranchValidationMiddleware(stack *middleware.Stack) error {
742	return stack.Initialize.Add(&validateOpCreateBranch{}, middleware.After)
743}
744
745func addOpCreateDeploymentValidationMiddleware(stack *middleware.Stack) error {
746	return stack.Initialize.Add(&validateOpCreateDeployment{}, middleware.After)
747}
748
749func addOpCreateDomainAssociationValidationMiddleware(stack *middleware.Stack) error {
750	return stack.Initialize.Add(&validateOpCreateDomainAssociation{}, middleware.After)
751}
752
753func addOpCreateWebhookValidationMiddleware(stack *middleware.Stack) error {
754	return stack.Initialize.Add(&validateOpCreateWebhook{}, middleware.After)
755}
756
757func addOpDeleteAppValidationMiddleware(stack *middleware.Stack) error {
758	return stack.Initialize.Add(&validateOpDeleteApp{}, middleware.After)
759}
760
761func addOpDeleteBackendEnvironmentValidationMiddleware(stack *middleware.Stack) error {
762	return stack.Initialize.Add(&validateOpDeleteBackendEnvironment{}, middleware.After)
763}
764
765func addOpDeleteBranchValidationMiddleware(stack *middleware.Stack) error {
766	return stack.Initialize.Add(&validateOpDeleteBranch{}, middleware.After)
767}
768
769func addOpDeleteDomainAssociationValidationMiddleware(stack *middleware.Stack) error {
770	return stack.Initialize.Add(&validateOpDeleteDomainAssociation{}, middleware.After)
771}
772
773func addOpDeleteJobValidationMiddleware(stack *middleware.Stack) error {
774	return stack.Initialize.Add(&validateOpDeleteJob{}, middleware.After)
775}
776
777func addOpDeleteWebhookValidationMiddleware(stack *middleware.Stack) error {
778	return stack.Initialize.Add(&validateOpDeleteWebhook{}, middleware.After)
779}
780
781func addOpGenerateAccessLogsValidationMiddleware(stack *middleware.Stack) error {
782	return stack.Initialize.Add(&validateOpGenerateAccessLogs{}, middleware.After)
783}
784
785func addOpGetAppValidationMiddleware(stack *middleware.Stack) error {
786	return stack.Initialize.Add(&validateOpGetApp{}, middleware.After)
787}
788
789func addOpGetArtifactUrlValidationMiddleware(stack *middleware.Stack) error {
790	return stack.Initialize.Add(&validateOpGetArtifactUrl{}, middleware.After)
791}
792
793func addOpGetBackendEnvironmentValidationMiddleware(stack *middleware.Stack) error {
794	return stack.Initialize.Add(&validateOpGetBackendEnvironment{}, middleware.After)
795}
796
797func addOpGetBranchValidationMiddleware(stack *middleware.Stack) error {
798	return stack.Initialize.Add(&validateOpGetBranch{}, middleware.After)
799}
800
801func addOpGetDomainAssociationValidationMiddleware(stack *middleware.Stack) error {
802	return stack.Initialize.Add(&validateOpGetDomainAssociation{}, middleware.After)
803}
804
805func addOpGetJobValidationMiddleware(stack *middleware.Stack) error {
806	return stack.Initialize.Add(&validateOpGetJob{}, middleware.After)
807}
808
809func addOpGetWebhookValidationMiddleware(stack *middleware.Stack) error {
810	return stack.Initialize.Add(&validateOpGetWebhook{}, middleware.After)
811}
812
813func addOpListArtifactsValidationMiddleware(stack *middleware.Stack) error {
814	return stack.Initialize.Add(&validateOpListArtifacts{}, middleware.After)
815}
816
817func addOpListBackendEnvironmentsValidationMiddleware(stack *middleware.Stack) error {
818	return stack.Initialize.Add(&validateOpListBackendEnvironments{}, middleware.After)
819}
820
821func addOpListBranchesValidationMiddleware(stack *middleware.Stack) error {
822	return stack.Initialize.Add(&validateOpListBranches{}, middleware.After)
823}
824
825func addOpListDomainAssociationsValidationMiddleware(stack *middleware.Stack) error {
826	return stack.Initialize.Add(&validateOpListDomainAssociations{}, middleware.After)
827}
828
829func addOpListJobsValidationMiddleware(stack *middleware.Stack) error {
830	return stack.Initialize.Add(&validateOpListJobs{}, middleware.After)
831}
832
833func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
834	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
835}
836
837func addOpListWebhooksValidationMiddleware(stack *middleware.Stack) error {
838	return stack.Initialize.Add(&validateOpListWebhooks{}, middleware.After)
839}
840
841func addOpStartDeploymentValidationMiddleware(stack *middleware.Stack) error {
842	return stack.Initialize.Add(&validateOpStartDeployment{}, middleware.After)
843}
844
845func addOpStartJobValidationMiddleware(stack *middleware.Stack) error {
846	return stack.Initialize.Add(&validateOpStartJob{}, middleware.After)
847}
848
849func addOpStopJobValidationMiddleware(stack *middleware.Stack) error {
850	return stack.Initialize.Add(&validateOpStopJob{}, middleware.After)
851}
852
853func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
854	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
855}
856
857func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
858	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
859}
860
861func addOpUpdateAppValidationMiddleware(stack *middleware.Stack) error {
862	return stack.Initialize.Add(&validateOpUpdateApp{}, middleware.After)
863}
864
865func addOpUpdateBranchValidationMiddleware(stack *middleware.Stack) error {
866	return stack.Initialize.Add(&validateOpUpdateBranch{}, middleware.After)
867}
868
869func addOpUpdateDomainAssociationValidationMiddleware(stack *middleware.Stack) error {
870	return stack.Initialize.Add(&validateOpUpdateDomainAssociation{}, middleware.After)
871}
872
873func addOpUpdateWebhookValidationMiddleware(stack *middleware.Stack) error {
874	return stack.Initialize.Add(&validateOpUpdateWebhook{}, middleware.After)
875}
876
877func validateCustomRule(v *types.CustomRule) error {
878	if v == nil {
879		return nil
880	}
881	invalidParams := smithy.InvalidParamsError{Context: "CustomRule"}
882	if v.Source == nil {
883		invalidParams.Add(smithy.NewErrParamRequired("Source"))
884	}
885	if v.Target == nil {
886		invalidParams.Add(smithy.NewErrParamRequired("Target"))
887	}
888	if invalidParams.Len() > 0 {
889		return invalidParams
890	} else {
891		return nil
892	}
893}
894
895func validateCustomRules(v []types.CustomRule) error {
896	if v == nil {
897		return nil
898	}
899	invalidParams := smithy.InvalidParamsError{Context: "CustomRules"}
900	for i := range v {
901		if err := validateCustomRule(&v[i]); err != nil {
902			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
903		}
904	}
905	if invalidParams.Len() > 0 {
906		return invalidParams
907	} else {
908		return nil
909	}
910}
911
912func validateSubDomainSetting(v *types.SubDomainSetting) error {
913	if v == nil {
914		return nil
915	}
916	invalidParams := smithy.InvalidParamsError{Context: "SubDomainSetting"}
917	if v.Prefix == nil {
918		invalidParams.Add(smithy.NewErrParamRequired("Prefix"))
919	}
920	if v.BranchName == nil {
921		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
922	}
923	if invalidParams.Len() > 0 {
924		return invalidParams
925	} else {
926		return nil
927	}
928}
929
930func validateSubDomainSettings(v []types.SubDomainSetting) error {
931	if v == nil {
932		return nil
933	}
934	invalidParams := smithy.InvalidParamsError{Context: "SubDomainSettings"}
935	for i := range v {
936		if err := validateSubDomainSetting(&v[i]); err != nil {
937			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
938		}
939	}
940	if invalidParams.Len() > 0 {
941		return invalidParams
942	} else {
943		return nil
944	}
945}
946
947func validateOpCreateAppInput(v *CreateAppInput) error {
948	if v == nil {
949		return nil
950	}
951	invalidParams := smithy.InvalidParamsError{Context: "CreateAppInput"}
952	if v.Name == nil {
953		invalidParams.Add(smithy.NewErrParamRequired("Name"))
954	}
955	if v.CustomRules != nil {
956		if err := validateCustomRules(v.CustomRules); err != nil {
957			invalidParams.AddNested("CustomRules", err.(smithy.InvalidParamsError))
958		}
959	}
960	if invalidParams.Len() > 0 {
961		return invalidParams
962	} else {
963		return nil
964	}
965}
966
967func validateOpCreateBackendEnvironmentInput(v *CreateBackendEnvironmentInput) error {
968	if v == nil {
969		return nil
970	}
971	invalidParams := smithy.InvalidParamsError{Context: "CreateBackendEnvironmentInput"}
972	if v.AppId == nil {
973		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
974	}
975	if v.EnvironmentName == nil {
976		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
977	}
978	if invalidParams.Len() > 0 {
979		return invalidParams
980	} else {
981		return nil
982	}
983}
984
985func validateOpCreateBranchInput(v *CreateBranchInput) error {
986	if v == nil {
987		return nil
988	}
989	invalidParams := smithy.InvalidParamsError{Context: "CreateBranchInput"}
990	if v.AppId == nil {
991		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
992	}
993	if v.BranchName == nil {
994		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
995	}
996	if invalidParams.Len() > 0 {
997		return invalidParams
998	} else {
999		return nil
1000	}
1001}
1002
1003func validateOpCreateDeploymentInput(v *CreateDeploymentInput) error {
1004	if v == nil {
1005		return nil
1006	}
1007	invalidParams := smithy.InvalidParamsError{Context: "CreateDeploymentInput"}
1008	if v.AppId == nil {
1009		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1010	}
1011	if v.BranchName == nil {
1012		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
1013	}
1014	if invalidParams.Len() > 0 {
1015		return invalidParams
1016	} else {
1017		return nil
1018	}
1019}
1020
1021func validateOpCreateDomainAssociationInput(v *CreateDomainAssociationInput) error {
1022	if v == nil {
1023		return nil
1024	}
1025	invalidParams := smithy.InvalidParamsError{Context: "CreateDomainAssociationInput"}
1026	if v.AppId == nil {
1027		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1028	}
1029	if v.DomainName == nil {
1030		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1031	}
1032	if v.SubDomainSettings == nil {
1033		invalidParams.Add(smithy.NewErrParamRequired("SubDomainSettings"))
1034	} else if v.SubDomainSettings != nil {
1035		if err := validateSubDomainSettings(v.SubDomainSettings); err != nil {
1036			invalidParams.AddNested("SubDomainSettings", err.(smithy.InvalidParamsError))
1037		}
1038	}
1039	if invalidParams.Len() > 0 {
1040		return invalidParams
1041	} else {
1042		return nil
1043	}
1044}
1045
1046func validateOpCreateWebhookInput(v *CreateWebhookInput) error {
1047	if v == nil {
1048		return nil
1049	}
1050	invalidParams := smithy.InvalidParamsError{Context: "CreateWebhookInput"}
1051	if v.AppId == nil {
1052		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1053	}
1054	if v.BranchName == nil {
1055		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
1056	}
1057	if invalidParams.Len() > 0 {
1058		return invalidParams
1059	} else {
1060		return nil
1061	}
1062}
1063
1064func validateOpDeleteAppInput(v *DeleteAppInput) error {
1065	if v == nil {
1066		return nil
1067	}
1068	invalidParams := smithy.InvalidParamsError{Context: "DeleteAppInput"}
1069	if v.AppId == nil {
1070		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1071	}
1072	if invalidParams.Len() > 0 {
1073		return invalidParams
1074	} else {
1075		return nil
1076	}
1077}
1078
1079func validateOpDeleteBackendEnvironmentInput(v *DeleteBackendEnvironmentInput) error {
1080	if v == nil {
1081		return nil
1082	}
1083	invalidParams := smithy.InvalidParamsError{Context: "DeleteBackendEnvironmentInput"}
1084	if v.AppId == nil {
1085		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1086	}
1087	if v.EnvironmentName == nil {
1088		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
1089	}
1090	if invalidParams.Len() > 0 {
1091		return invalidParams
1092	} else {
1093		return nil
1094	}
1095}
1096
1097func validateOpDeleteBranchInput(v *DeleteBranchInput) error {
1098	if v == nil {
1099		return nil
1100	}
1101	invalidParams := smithy.InvalidParamsError{Context: "DeleteBranchInput"}
1102	if v.AppId == nil {
1103		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1104	}
1105	if v.BranchName == nil {
1106		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
1107	}
1108	if invalidParams.Len() > 0 {
1109		return invalidParams
1110	} else {
1111		return nil
1112	}
1113}
1114
1115func validateOpDeleteDomainAssociationInput(v *DeleteDomainAssociationInput) error {
1116	if v == nil {
1117		return nil
1118	}
1119	invalidParams := smithy.InvalidParamsError{Context: "DeleteDomainAssociationInput"}
1120	if v.AppId == nil {
1121		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1122	}
1123	if v.DomainName == nil {
1124		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1125	}
1126	if invalidParams.Len() > 0 {
1127		return invalidParams
1128	} else {
1129		return nil
1130	}
1131}
1132
1133func validateOpDeleteJobInput(v *DeleteJobInput) error {
1134	if v == nil {
1135		return nil
1136	}
1137	invalidParams := smithy.InvalidParamsError{Context: "DeleteJobInput"}
1138	if v.AppId == nil {
1139		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1140	}
1141	if v.BranchName == nil {
1142		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
1143	}
1144	if v.JobId == nil {
1145		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1146	}
1147	if invalidParams.Len() > 0 {
1148		return invalidParams
1149	} else {
1150		return nil
1151	}
1152}
1153
1154func validateOpDeleteWebhookInput(v *DeleteWebhookInput) error {
1155	if v == nil {
1156		return nil
1157	}
1158	invalidParams := smithy.InvalidParamsError{Context: "DeleteWebhookInput"}
1159	if v.WebhookId == nil {
1160		invalidParams.Add(smithy.NewErrParamRequired("WebhookId"))
1161	}
1162	if invalidParams.Len() > 0 {
1163		return invalidParams
1164	} else {
1165		return nil
1166	}
1167}
1168
1169func validateOpGenerateAccessLogsInput(v *GenerateAccessLogsInput) error {
1170	if v == nil {
1171		return nil
1172	}
1173	invalidParams := smithy.InvalidParamsError{Context: "GenerateAccessLogsInput"}
1174	if v.DomainName == nil {
1175		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1176	}
1177	if v.AppId == nil {
1178		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1179	}
1180	if invalidParams.Len() > 0 {
1181		return invalidParams
1182	} else {
1183		return nil
1184	}
1185}
1186
1187func validateOpGetAppInput(v *GetAppInput) error {
1188	if v == nil {
1189		return nil
1190	}
1191	invalidParams := smithy.InvalidParamsError{Context: "GetAppInput"}
1192	if v.AppId == nil {
1193		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1194	}
1195	if invalidParams.Len() > 0 {
1196		return invalidParams
1197	} else {
1198		return nil
1199	}
1200}
1201
1202func validateOpGetArtifactUrlInput(v *GetArtifactUrlInput) error {
1203	if v == nil {
1204		return nil
1205	}
1206	invalidParams := smithy.InvalidParamsError{Context: "GetArtifactUrlInput"}
1207	if v.ArtifactId == nil {
1208		invalidParams.Add(smithy.NewErrParamRequired("ArtifactId"))
1209	}
1210	if invalidParams.Len() > 0 {
1211		return invalidParams
1212	} else {
1213		return nil
1214	}
1215}
1216
1217func validateOpGetBackendEnvironmentInput(v *GetBackendEnvironmentInput) error {
1218	if v == nil {
1219		return nil
1220	}
1221	invalidParams := smithy.InvalidParamsError{Context: "GetBackendEnvironmentInput"}
1222	if v.AppId == nil {
1223		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1224	}
1225	if v.EnvironmentName == nil {
1226		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentName"))
1227	}
1228	if invalidParams.Len() > 0 {
1229		return invalidParams
1230	} else {
1231		return nil
1232	}
1233}
1234
1235func validateOpGetBranchInput(v *GetBranchInput) error {
1236	if v == nil {
1237		return nil
1238	}
1239	invalidParams := smithy.InvalidParamsError{Context: "GetBranchInput"}
1240	if v.AppId == nil {
1241		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1242	}
1243	if v.BranchName == nil {
1244		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
1245	}
1246	if invalidParams.Len() > 0 {
1247		return invalidParams
1248	} else {
1249		return nil
1250	}
1251}
1252
1253func validateOpGetDomainAssociationInput(v *GetDomainAssociationInput) error {
1254	if v == nil {
1255		return nil
1256	}
1257	invalidParams := smithy.InvalidParamsError{Context: "GetDomainAssociationInput"}
1258	if v.AppId == nil {
1259		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1260	}
1261	if v.DomainName == nil {
1262		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1263	}
1264	if invalidParams.Len() > 0 {
1265		return invalidParams
1266	} else {
1267		return nil
1268	}
1269}
1270
1271func validateOpGetJobInput(v *GetJobInput) error {
1272	if v == nil {
1273		return nil
1274	}
1275	invalidParams := smithy.InvalidParamsError{Context: "GetJobInput"}
1276	if v.AppId == nil {
1277		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1278	}
1279	if v.BranchName == nil {
1280		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
1281	}
1282	if v.JobId == nil {
1283		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1284	}
1285	if invalidParams.Len() > 0 {
1286		return invalidParams
1287	} else {
1288		return nil
1289	}
1290}
1291
1292func validateOpGetWebhookInput(v *GetWebhookInput) error {
1293	if v == nil {
1294		return nil
1295	}
1296	invalidParams := smithy.InvalidParamsError{Context: "GetWebhookInput"}
1297	if v.WebhookId == nil {
1298		invalidParams.Add(smithy.NewErrParamRequired("WebhookId"))
1299	}
1300	if invalidParams.Len() > 0 {
1301		return invalidParams
1302	} else {
1303		return nil
1304	}
1305}
1306
1307func validateOpListArtifactsInput(v *ListArtifactsInput) error {
1308	if v == nil {
1309		return nil
1310	}
1311	invalidParams := smithy.InvalidParamsError{Context: "ListArtifactsInput"}
1312	if v.AppId == nil {
1313		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1314	}
1315	if v.BranchName == nil {
1316		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
1317	}
1318	if v.JobId == nil {
1319		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1320	}
1321	if invalidParams.Len() > 0 {
1322		return invalidParams
1323	} else {
1324		return nil
1325	}
1326}
1327
1328func validateOpListBackendEnvironmentsInput(v *ListBackendEnvironmentsInput) error {
1329	if v == nil {
1330		return nil
1331	}
1332	invalidParams := smithy.InvalidParamsError{Context: "ListBackendEnvironmentsInput"}
1333	if v.AppId == nil {
1334		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1335	}
1336	if invalidParams.Len() > 0 {
1337		return invalidParams
1338	} else {
1339		return nil
1340	}
1341}
1342
1343func validateOpListBranchesInput(v *ListBranchesInput) error {
1344	if v == nil {
1345		return nil
1346	}
1347	invalidParams := smithy.InvalidParamsError{Context: "ListBranchesInput"}
1348	if v.AppId == nil {
1349		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1350	}
1351	if invalidParams.Len() > 0 {
1352		return invalidParams
1353	} else {
1354		return nil
1355	}
1356}
1357
1358func validateOpListDomainAssociationsInput(v *ListDomainAssociationsInput) error {
1359	if v == nil {
1360		return nil
1361	}
1362	invalidParams := smithy.InvalidParamsError{Context: "ListDomainAssociationsInput"}
1363	if v.AppId == nil {
1364		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1365	}
1366	if invalidParams.Len() > 0 {
1367		return invalidParams
1368	} else {
1369		return nil
1370	}
1371}
1372
1373func validateOpListJobsInput(v *ListJobsInput) error {
1374	if v == nil {
1375		return nil
1376	}
1377	invalidParams := smithy.InvalidParamsError{Context: "ListJobsInput"}
1378	if v.AppId == nil {
1379		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1380	}
1381	if v.BranchName == nil {
1382		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
1383	}
1384	if invalidParams.Len() > 0 {
1385		return invalidParams
1386	} else {
1387		return nil
1388	}
1389}
1390
1391func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1392	if v == nil {
1393		return nil
1394	}
1395	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1396	if v.ResourceArn == nil {
1397		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1398	}
1399	if invalidParams.Len() > 0 {
1400		return invalidParams
1401	} else {
1402		return nil
1403	}
1404}
1405
1406func validateOpListWebhooksInput(v *ListWebhooksInput) error {
1407	if v == nil {
1408		return nil
1409	}
1410	invalidParams := smithy.InvalidParamsError{Context: "ListWebhooksInput"}
1411	if v.AppId == nil {
1412		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1413	}
1414	if invalidParams.Len() > 0 {
1415		return invalidParams
1416	} else {
1417		return nil
1418	}
1419}
1420
1421func validateOpStartDeploymentInput(v *StartDeploymentInput) error {
1422	if v == nil {
1423		return nil
1424	}
1425	invalidParams := smithy.InvalidParamsError{Context: "StartDeploymentInput"}
1426	if v.AppId == nil {
1427		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1428	}
1429	if v.BranchName == nil {
1430		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
1431	}
1432	if invalidParams.Len() > 0 {
1433		return invalidParams
1434	} else {
1435		return nil
1436	}
1437}
1438
1439func validateOpStartJobInput(v *StartJobInput) error {
1440	if v == nil {
1441		return nil
1442	}
1443	invalidParams := smithy.InvalidParamsError{Context: "StartJobInput"}
1444	if v.AppId == nil {
1445		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1446	}
1447	if v.BranchName == nil {
1448		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
1449	}
1450	if len(v.JobType) == 0 {
1451		invalidParams.Add(smithy.NewErrParamRequired("JobType"))
1452	}
1453	if invalidParams.Len() > 0 {
1454		return invalidParams
1455	} else {
1456		return nil
1457	}
1458}
1459
1460func validateOpStopJobInput(v *StopJobInput) error {
1461	if v == nil {
1462		return nil
1463	}
1464	invalidParams := smithy.InvalidParamsError{Context: "StopJobInput"}
1465	if v.AppId == nil {
1466		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1467	}
1468	if v.BranchName == nil {
1469		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
1470	}
1471	if v.JobId == nil {
1472		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
1473	}
1474	if invalidParams.Len() > 0 {
1475		return invalidParams
1476	} else {
1477		return nil
1478	}
1479}
1480
1481func validateOpTagResourceInput(v *TagResourceInput) error {
1482	if v == nil {
1483		return nil
1484	}
1485	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
1486	if v.ResourceArn == nil {
1487		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1488	}
1489	if v.Tags == nil {
1490		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1491	}
1492	if invalidParams.Len() > 0 {
1493		return invalidParams
1494	} else {
1495		return nil
1496	}
1497}
1498
1499func validateOpUntagResourceInput(v *UntagResourceInput) error {
1500	if v == nil {
1501		return nil
1502	}
1503	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
1504	if v.ResourceArn == nil {
1505		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1506	}
1507	if v.TagKeys == nil {
1508		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1509	}
1510	if invalidParams.Len() > 0 {
1511		return invalidParams
1512	} else {
1513		return nil
1514	}
1515}
1516
1517func validateOpUpdateAppInput(v *UpdateAppInput) error {
1518	if v == nil {
1519		return nil
1520	}
1521	invalidParams := smithy.InvalidParamsError{Context: "UpdateAppInput"}
1522	if v.AppId == nil {
1523		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1524	}
1525	if v.CustomRules != nil {
1526		if err := validateCustomRules(v.CustomRules); err != nil {
1527			invalidParams.AddNested("CustomRules", err.(smithy.InvalidParamsError))
1528		}
1529	}
1530	if invalidParams.Len() > 0 {
1531		return invalidParams
1532	} else {
1533		return nil
1534	}
1535}
1536
1537func validateOpUpdateBranchInput(v *UpdateBranchInput) error {
1538	if v == nil {
1539		return nil
1540	}
1541	invalidParams := smithy.InvalidParamsError{Context: "UpdateBranchInput"}
1542	if v.AppId == nil {
1543		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1544	}
1545	if v.BranchName == nil {
1546		invalidParams.Add(smithy.NewErrParamRequired("BranchName"))
1547	}
1548	if invalidParams.Len() > 0 {
1549		return invalidParams
1550	} else {
1551		return nil
1552	}
1553}
1554
1555func validateOpUpdateDomainAssociationInput(v *UpdateDomainAssociationInput) error {
1556	if v == nil {
1557		return nil
1558	}
1559	invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainAssociationInput"}
1560	if v.AppId == nil {
1561		invalidParams.Add(smithy.NewErrParamRequired("AppId"))
1562	}
1563	if v.DomainName == nil {
1564		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1565	}
1566	if v.SubDomainSettings == nil {
1567		invalidParams.Add(smithy.NewErrParamRequired("SubDomainSettings"))
1568	} else if v.SubDomainSettings != nil {
1569		if err := validateSubDomainSettings(v.SubDomainSettings); err != nil {
1570			invalidParams.AddNested("SubDomainSettings", err.(smithy.InvalidParamsError))
1571		}
1572	}
1573	if invalidParams.Len() > 0 {
1574		return invalidParams
1575	} else {
1576		return nil
1577	}
1578}
1579
1580func validateOpUpdateWebhookInput(v *UpdateWebhookInput) error {
1581	if v == nil {
1582		return nil
1583	}
1584	invalidParams := smithy.InvalidParamsError{Context: "UpdateWebhookInput"}
1585	if v.WebhookId == nil {
1586		invalidParams.Add(smithy.NewErrParamRequired("WebhookId"))
1587	}
1588	if invalidParams.Len() > 0 {
1589		return invalidParams
1590	} else {
1591		return nil
1592	}
1593}
1594