1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package apigatewayv2
4
5import (
6	"context"
7	"fmt"
8	smithy "github.com/aws/smithy-go"
9	"github.com/aws/smithy-go/middleware"
10)
11
12type validateOpCreateApi struct {
13}
14
15func (*validateOpCreateApi) ID() string {
16	return "OperationInputValidation"
17}
18
19func (m *validateOpCreateApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
20	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
21) {
22	input, ok := in.Parameters.(*CreateApiInput)
23	if !ok {
24		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
25	}
26	if err := validateOpCreateApiInput(input); err != nil {
27		return out, metadata, err
28	}
29	return next.HandleInitialize(ctx, in)
30}
31
32type validateOpCreateApiMapping struct {
33}
34
35func (*validateOpCreateApiMapping) ID() string {
36	return "OperationInputValidation"
37}
38
39func (m *validateOpCreateApiMapping) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
40	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
41) {
42	input, ok := in.Parameters.(*CreateApiMappingInput)
43	if !ok {
44		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
45	}
46	if err := validateOpCreateApiMappingInput(input); err != nil {
47		return out, metadata, err
48	}
49	return next.HandleInitialize(ctx, in)
50}
51
52type validateOpCreateAuthorizer struct {
53}
54
55func (*validateOpCreateAuthorizer) ID() string {
56	return "OperationInputValidation"
57}
58
59func (m *validateOpCreateAuthorizer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
60	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
61) {
62	input, ok := in.Parameters.(*CreateAuthorizerInput)
63	if !ok {
64		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
65	}
66	if err := validateOpCreateAuthorizerInput(input); err != nil {
67		return out, metadata, err
68	}
69	return next.HandleInitialize(ctx, in)
70}
71
72type validateOpCreateDeployment struct {
73}
74
75func (*validateOpCreateDeployment) ID() string {
76	return "OperationInputValidation"
77}
78
79func (m *validateOpCreateDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
80	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
81) {
82	input, ok := in.Parameters.(*CreateDeploymentInput)
83	if !ok {
84		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
85	}
86	if err := validateOpCreateDeploymentInput(input); err != nil {
87		return out, metadata, err
88	}
89	return next.HandleInitialize(ctx, in)
90}
91
92type validateOpCreateDomainName struct {
93}
94
95func (*validateOpCreateDomainName) ID() string {
96	return "OperationInputValidation"
97}
98
99func (m *validateOpCreateDomainName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
100	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
101) {
102	input, ok := in.Parameters.(*CreateDomainNameInput)
103	if !ok {
104		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
105	}
106	if err := validateOpCreateDomainNameInput(input); err != nil {
107		return out, metadata, err
108	}
109	return next.HandleInitialize(ctx, in)
110}
111
112type validateOpCreateIntegration struct {
113}
114
115func (*validateOpCreateIntegration) ID() string {
116	return "OperationInputValidation"
117}
118
119func (m *validateOpCreateIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
120	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
121) {
122	input, ok := in.Parameters.(*CreateIntegrationInput)
123	if !ok {
124		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
125	}
126	if err := validateOpCreateIntegrationInput(input); err != nil {
127		return out, metadata, err
128	}
129	return next.HandleInitialize(ctx, in)
130}
131
132type validateOpCreateIntegrationResponse struct {
133}
134
135func (*validateOpCreateIntegrationResponse) ID() string {
136	return "OperationInputValidation"
137}
138
139func (m *validateOpCreateIntegrationResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
140	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
141) {
142	input, ok := in.Parameters.(*CreateIntegrationResponseInput)
143	if !ok {
144		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
145	}
146	if err := validateOpCreateIntegrationResponseInput(input); err != nil {
147		return out, metadata, err
148	}
149	return next.HandleInitialize(ctx, in)
150}
151
152type validateOpCreateModel struct {
153}
154
155func (*validateOpCreateModel) ID() string {
156	return "OperationInputValidation"
157}
158
159func (m *validateOpCreateModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
160	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
161) {
162	input, ok := in.Parameters.(*CreateModelInput)
163	if !ok {
164		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
165	}
166	if err := validateOpCreateModelInput(input); err != nil {
167		return out, metadata, err
168	}
169	return next.HandleInitialize(ctx, in)
170}
171
172type validateOpCreateRoute struct {
173}
174
175func (*validateOpCreateRoute) ID() string {
176	return "OperationInputValidation"
177}
178
179func (m *validateOpCreateRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
180	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
181) {
182	input, ok := in.Parameters.(*CreateRouteInput)
183	if !ok {
184		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
185	}
186	if err := validateOpCreateRouteInput(input); err != nil {
187		return out, metadata, err
188	}
189	return next.HandleInitialize(ctx, in)
190}
191
192type validateOpCreateRouteResponse struct {
193}
194
195func (*validateOpCreateRouteResponse) ID() string {
196	return "OperationInputValidation"
197}
198
199func (m *validateOpCreateRouteResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
200	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
201) {
202	input, ok := in.Parameters.(*CreateRouteResponseInput)
203	if !ok {
204		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
205	}
206	if err := validateOpCreateRouteResponseInput(input); err != nil {
207		return out, metadata, err
208	}
209	return next.HandleInitialize(ctx, in)
210}
211
212type validateOpCreateStage struct {
213}
214
215func (*validateOpCreateStage) ID() string {
216	return "OperationInputValidation"
217}
218
219func (m *validateOpCreateStage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
220	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
221) {
222	input, ok := in.Parameters.(*CreateStageInput)
223	if !ok {
224		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
225	}
226	if err := validateOpCreateStageInput(input); err != nil {
227		return out, metadata, err
228	}
229	return next.HandleInitialize(ctx, in)
230}
231
232type validateOpCreateVpcLink struct {
233}
234
235func (*validateOpCreateVpcLink) ID() string {
236	return "OperationInputValidation"
237}
238
239func (m *validateOpCreateVpcLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
240	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
241) {
242	input, ok := in.Parameters.(*CreateVpcLinkInput)
243	if !ok {
244		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
245	}
246	if err := validateOpCreateVpcLinkInput(input); err != nil {
247		return out, metadata, err
248	}
249	return next.HandleInitialize(ctx, in)
250}
251
252type validateOpDeleteAccessLogSettings struct {
253}
254
255func (*validateOpDeleteAccessLogSettings) ID() string {
256	return "OperationInputValidation"
257}
258
259func (m *validateOpDeleteAccessLogSettings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
260	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
261) {
262	input, ok := in.Parameters.(*DeleteAccessLogSettingsInput)
263	if !ok {
264		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
265	}
266	if err := validateOpDeleteAccessLogSettingsInput(input); err != nil {
267		return out, metadata, err
268	}
269	return next.HandleInitialize(ctx, in)
270}
271
272type validateOpDeleteApi struct {
273}
274
275func (*validateOpDeleteApi) ID() string {
276	return "OperationInputValidation"
277}
278
279func (m *validateOpDeleteApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
280	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
281) {
282	input, ok := in.Parameters.(*DeleteApiInput)
283	if !ok {
284		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
285	}
286	if err := validateOpDeleteApiInput(input); err != nil {
287		return out, metadata, err
288	}
289	return next.HandleInitialize(ctx, in)
290}
291
292type validateOpDeleteApiMapping struct {
293}
294
295func (*validateOpDeleteApiMapping) ID() string {
296	return "OperationInputValidation"
297}
298
299func (m *validateOpDeleteApiMapping) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
300	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
301) {
302	input, ok := in.Parameters.(*DeleteApiMappingInput)
303	if !ok {
304		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
305	}
306	if err := validateOpDeleteApiMappingInput(input); err != nil {
307		return out, metadata, err
308	}
309	return next.HandleInitialize(ctx, in)
310}
311
312type validateOpDeleteAuthorizer struct {
313}
314
315func (*validateOpDeleteAuthorizer) ID() string {
316	return "OperationInputValidation"
317}
318
319func (m *validateOpDeleteAuthorizer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
320	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
321) {
322	input, ok := in.Parameters.(*DeleteAuthorizerInput)
323	if !ok {
324		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
325	}
326	if err := validateOpDeleteAuthorizerInput(input); err != nil {
327		return out, metadata, err
328	}
329	return next.HandleInitialize(ctx, in)
330}
331
332type validateOpDeleteCorsConfiguration struct {
333}
334
335func (*validateOpDeleteCorsConfiguration) ID() string {
336	return "OperationInputValidation"
337}
338
339func (m *validateOpDeleteCorsConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
340	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
341) {
342	input, ok := in.Parameters.(*DeleteCorsConfigurationInput)
343	if !ok {
344		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
345	}
346	if err := validateOpDeleteCorsConfigurationInput(input); err != nil {
347		return out, metadata, err
348	}
349	return next.HandleInitialize(ctx, in)
350}
351
352type validateOpDeleteDeployment struct {
353}
354
355func (*validateOpDeleteDeployment) ID() string {
356	return "OperationInputValidation"
357}
358
359func (m *validateOpDeleteDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
360	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
361) {
362	input, ok := in.Parameters.(*DeleteDeploymentInput)
363	if !ok {
364		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
365	}
366	if err := validateOpDeleteDeploymentInput(input); err != nil {
367		return out, metadata, err
368	}
369	return next.HandleInitialize(ctx, in)
370}
371
372type validateOpDeleteDomainName struct {
373}
374
375func (*validateOpDeleteDomainName) ID() string {
376	return "OperationInputValidation"
377}
378
379func (m *validateOpDeleteDomainName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
380	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
381) {
382	input, ok := in.Parameters.(*DeleteDomainNameInput)
383	if !ok {
384		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
385	}
386	if err := validateOpDeleteDomainNameInput(input); err != nil {
387		return out, metadata, err
388	}
389	return next.HandleInitialize(ctx, in)
390}
391
392type validateOpDeleteIntegration struct {
393}
394
395func (*validateOpDeleteIntegration) ID() string {
396	return "OperationInputValidation"
397}
398
399func (m *validateOpDeleteIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
400	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
401) {
402	input, ok := in.Parameters.(*DeleteIntegrationInput)
403	if !ok {
404		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
405	}
406	if err := validateOpDeleteIntegrationInput(input); err != nil {
407		return out, metadata, err
408	}
409	return next.HandleInitialize(ctx, in)
410}
411
412type validateOpDeleteIntegrationResponse struct {
413}
414
415func (*validateOpDeleteIntegrationResponse) ID() string {
416	return "OperationInputValidation"
417}
418
419func (m *validateOpDeleteIntegrationResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
420	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
421) {
422	input, ok := in.Parameters.(*DeleteIntegrationResponseInput)
423	if !ok {
424		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
425	}
426	if err := validateOpDeleteIntegrationResponseInput(input); err != nil {
427		return out, metadata, err
428	}
429	return next.HandleInitialize(ctx, in)
430}
431
432type validateOpDeleteModel struct {
433}
434
435func (*validateOpDeleteModel) ID() string {
436	return "OperationInputValidation"
437}
438
439func (m *validateOpDeleteModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
440	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
441) {
442	input, ok := in.Parameters.(*DeleteModelInput)
443	if !ok {
444		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
445	}
446	if err := validateOpDeleteModelInput(input); err != nil {
447		return out, metadata, err
448	}
449	return next.HandleInitialize(ctx, in)
450}
451
452type validateOpDeleteRoute struct {
453}
454
455func (*validateOpDeleteRoute) ID() string {
456	return "OperationInputValidation"
457}
458
459func (m *validateOpDeleteRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
460	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
461) {
462	input, ok := in.Parameters.(*DeleteRouteInput)
463	if !ok {
464		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
465	}
466	if err := validateOpDeleteRouteInput(input); err != nil {
467		return out, metadata, err
468	}
469	return next.HandleInitialize(ctx, in)
470}
471
472type validateOpDeleteRouteRequestParameter struct {
473}
474
475func (*validateOpDeleteRouteRequestParameter) ID() string {
476	return "OperationInputValidation"
477}
478
479func (m *validateOpDeleteRouteRequestParameter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
480	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
481) {
482	input, ok := in.Parameters.(*DeleteRouteRequestParameterInput)
483	if !ok {
484		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
485	}
486	if err := validateOpDeleteRouteRequestParameterInput(input); err != nil {
487		return out, metadata, err
488	}
489	return next.HandleInitialize(ctx, in)
490}
491
492type validateOpDeleteRouteResponse struct {
493}
494
495func (*validateOpDeleteRouteResponse) ID() string {
496	return "OperationInputValidation"
497}
498
499func (m *validateOpDeleteRouteResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
500	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
501) {
502	input, ok := in.Parameters.(*DeleteRouteResponseInput)
503	if !ok {
504		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
505	}
506	if err := validateOpDeleteRouteResponseInput(input); err != nil {
507		return out, metadata, err
508	}
509	return next.HandleInitialize(ctx, in)
510}
511
512type validateOpDeleteRouteSettings struct {
513}
514
515func (*validateOpDeleteRouteSettings) ID() string {
516	return "OperationInputValidation"
517}
518
519func (m *validateOpDeleteRouteSettings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
520	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
521) {
522	input, ok := in.Parameters.(*DeleteRouteSettingsInput)
523	if !ok {
524		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
525	}
526	if err := validateOpDeleteRouteSettingsInput(input); err != nil {
527		return out, metadata, err
528	}
529	return next.HandleInitialize(ctx, in)
530}
531
532type validateOpDeleteStage struct {
533}
534
535func (*validateOpDeleteStage) ID() string {
536	return "OperationInputValidation"
537}
538
539func (m *validateOpDeleteStage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
540	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
541) {
542	input, ok := in.Parameters.(*DeleteStageInput)
543	if !ok {
544		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
545	}
546	if err := validateOpDeleteStageInput(input); err != nil {
547		return out, metadata, err
548	}
549	return next.HandleInitialize(ctx, in)
550}
551
552type validateOpDeleteVpcLink struct {
553}
554
555func (*validateOpDeleteVpcLink) ID() string {
556	return "OperationInputValidation"
557}
558
559func (m *validateOpDeleteVpcLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
560	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
561) {
562	input, ok := in.Parameters.(*DeleteVpcLinkInput)
563	if !ok {
564		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
565	}
566	if err := validateOpDeleteVpcLinkInput(input); err != nil {
567		return out, metadata, err
568	}
569	return next.HandleInitialize(ctx, in)
570}
571
572type validateOpExportApi struct {
573}
574
575func (*validateOpExportApi) ID() string {
576	return "OperationInputValidation"
577}
578
579func (m *validateOpExportApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
580	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
581) {
582	input, ok := in.Parameters.(*ExportApiInput)
583	if !ok {
584		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
585	}
586	if err := validateOpExportApiInput(input); err != nil {
587		return out, metadata, err
588	}
589	return next.HandleInitialize(ctx, in)
590}
591
592type validateOpGetApi struct {
593}
594
595func (*validateOpGetApi) ID() string {
596	return "OperationInputValidation"
597}
598
599func (m *validateOpGetApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
600	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
601) {
602	input, ok := in.Parameters.(*GetApiInput)
603	if !ok {
604		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
605	}
606	if err := validateOpGetApiInput(input); err != nil {
607		return out, metadata, err
608	}
609	return next.HandleInitialize(ctx, in)
610}
611
612type validateOpGetApiMapping struct {
613}
614
615func (*validateOpGetApiMapping) ID() string {
616	return "OperationInputValidation"
617}
618
619func (m *validateOpGetApiMapping) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
620	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
621) {
622	input, ok := in.Parameters.(*GetApiMappingInput)
623	if !ok {
624		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
625	}
626	if err := validateOpGetApiMappingInput(input); err != nil {
627		return out, metadata, err
628	}
629	return next.HandleInitialize(ctx, in)
630}
631
632type validateOpGetApiMappings struct {
633}
634
635func (*validateOpGetApiMappings) ID() string {
636	return "OperationInputValidation"
637}
638
639func (m *validateOpGetApiMappings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
640	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
641) {
642	input, ok := in.Parameters.(*GetApiMappingsInput)
643	if !ok {
644		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
645	}
646	if err := validateOpGetApiMappingsInput(input); err != nil {
647		return out, metadata, err
648	}
649	return next.HandleInitialize(ctx, in)
650}
651
652type validateOpGetAuthorizer struct {
653}
654
655func (*validateOpGetAuthorizer) ID() string {
656	return "OperationInputValidation"
657}
658
659func (m *validateOpGetAuthorizer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
660	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
661) {
662	input, ok := in.Parameters.(*GetAuthorizerInput)
663	if !ok {
664		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
665	}
666	if err := validateOpGetAuthorizerInput(input); err != nil {
667		return out, metadata, err
668	}
669	return next.HandleInitialize(ctx, in)
670}
671
672type validateOpGetAuthorizers struct {
673}
674
675func (*validateOpGetAuthorizers) ID() string {
676	return "OperationInputValidation"
677}
678
679func (m *validateOpGetAuthorizers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
680	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
681) {
682	input, ok := in.Parameters.(*GetAuthorizersInput)
683	if !ok {
684		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
685	}
686	if err := validateOpGetAuthorizersInput(input); err != nil {
687		return out, metadata, err
688	}
689	return next.HandleInitialize(ctx, in)
690}
691
692type validateOpGetDeployment struct {
693}
694
695func (*validateOpGetDeployment) ID() string {
696	return "OperationInputValidation"
697}
698
699func (m *validateOpGetDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
700	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
701) {
702	input, ok := in.Parameters.(*GetDeploymentInput)
703	if !ok {
704		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
705	}
706	if err := validateOpGetDeploymentInput(input); err != nil {
707		return out, metadata, err
708	}
709	return next.HandleInitialize(ctx, in)
710}
711
712type validateOpGetDeployments struct {
713}
714
715func (*validateOpGetDeployments) ID() string {
716	return "OperationInputValidation"
717}
718
719func (m *validateOpGetDeployments) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
720	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
721) {
722	input, ok := in.Parameters.(*GetDeploymentsInput)
723	if !ok {
724		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
725	}
726	if err := validateOpGetDeploymentsInput(input); err != nil {
727		return out, metadata, err
728	}
729	return next.HandleInitialize(ctx, in)
730}
731
732type validateOpGetDomainName struct {
733}
734
735func (*validateOpGetDomainName) ID() string {
736	return "OperationInputValidation"
737}
738
739func (m *validateOpGetDomainName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
740	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
741) {
742	input, ok := in.Parameters.(*GetDomainNameInput)
743	if !ok {
744		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
745	}
746	if err := validateOpGetDomainNameInput(input); err != nil {
747		return out, metadata, err
748	}
749	return next.HandleInitialize(ctx, in)
750}
751
752type validateOpGetIntegration struct {
753}
754
755func (*validateOpGetIntegration) ID() string {
756	return "OperationInputValidation"
757}
758
759func (m *validateOpGetIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
760	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
761) {
762	input, ok := in.Parameters.(*GetIntegrationInput)
763	if !ok {
764		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
765	}
766	if err := validateOpGetIntegrationInput(input); err != nil {
767		return out, metadata, err
768	}
769	return next.HandleInitialize(ctx, in)
770}
771
772type validateOpGetIntegrationResponse struct {
773}
774
775func (*validateOpGetIntegrationResponse) ID() string {
776	return "OperationInputValidation"
777}
778
779func (m *validateOpGetIntegrationResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
780	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
781) {
782	input, ok := in.Parameters.(*GetIntegrationResponseInput)
783	if !ok {
784		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
785	}
786	if err := validateOpGetIntegrationResponseInput(input); err != nil {
787		return out, metadata, err
788	}
789	return next.HandleInitialize(ctx, in)
790}
791
792type validateOpGetIntegrationResponses struct {
793}
794
795func (*validateOpGetIntegrationResponses) ID() string {
796	return "OperationInputValidation"
797}
798
799func (m *validateOpGetIntegrationResponses) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
800	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
801) {
802	input, ok := in.Parameters.(*GetIntegrationResponsesInput)
803	if !ok {
804		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
805	}
806	if err := validateOpGetIntegrationResponsesInput(input); err != nil {
807		return out, metadata, err
808	}
809	return next.HandleInitialize(ctx, in)
810}
811
812type validateOpGetIntegrations struct {
813}
814
815func (*validateOpGetIntegrations) ID() string {
816	return "OperationInputValidation"
817}
818
819func (m *validateOpGetIntegrations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
820	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
821) {
822	input, ok := in.Parameters.(*GetIntegrationsInput)
823	if !ok {
824		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
825	}
826	if err := validateOpGetIntegrationsInput(input); err != nil {
827		return out, metadata, err
828	}
829	return next.HandleInitialize(ctx, in)
830}
831
832type validateOpGetModel struct {
833}
834
835func (*validateOpGetModel) ID() string {
836	return "OperationInputValidation"
837}
838
839func (m *validateOpGetModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
840	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
841) {
842	input, ok := in.Parameters.(*GetModelInput)
843	if !ok {
844		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
845	}
846	if err := validateOpGetModelInput(input); err != nil {
847		return out, metadata, err
848	}
849	return next.HandleInitialize(ctx, in)
850}
851
852type validateOpGetModels struct {
853}
854
855func (*validateOpGetModels) ID() string {
856	return "OperationInputValidation"
857}
858
859func (m *validateOpGetModels) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
860	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
861) {
862	input, ok := in.Parameters.(*GetModelsInput)
863	if !ok {
864		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
865	}
866	if err := validateOpGetModelsInput(input); err != nil {
867		return out, metadata, err
868	}
869	return next.HandleInitialize(ctx, in)
870}
871
872type validateOpGetModelTemplate struct {
873}
874
875func (*validateOpGetModelTemplate) ID() string {
876	return "OperationInputValidation"
877}
878
879func (m *validateOpGetModelTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
880	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
881) {
882	input, ok := in.Parameters.(*GetModelTemplateInput)
883	if !ok {
884		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
885	}
886	if err := validateOpGetModelTemplateInput(input); err != nil {
887		return out, metadata, err
888	}
889	return next.HandleInitialize(ctx, in)
890}
891
892type validateOpGetRoute struct {
893}
894
895func (*validateOpGetRoute) ID() string {
896	return "OperationInputValidation"
897}
898
899func (m *validateOpGetRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
900	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
901) {
902	input, ok := in.Parameters.(*GetRouteInput)
903	if !ok {
904		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
905	}
906	if err := validateOpGetRouteInput(input); err != nil {
907		return out, metadata, err
908	}
909	return next.HandleInitialize(ctx, in)
910}
911
912type validateOpGetRouteResponse struct {
913}
914
915func (*validateOpGetRouteResponse) ID() string {
916	return "OperationInputValidation"
917}
918
919func (m *validateOpGetRouteResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
920	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
921) {
922	input, ok := in.Parameters.(*GetRouteResponseInput)
923	if !ok {
924		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
925	}
926	if err := validateOpGetRouteResponseInput(input); err != nil {
927		return out, metadata, err
928	}
929	return next.HandleInitialize(ctx, in)
930}
931
932type validateOpGetRouteResponses struct {
933}
934
935func (*validateOpGetRouteResponses) ID() string {
936	return "OperationInputValidation"
937}
938
939func (m *validateOpGetRouteResponses) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
940	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
941) {
942	input, ok := in.Parameters.(*GetRouteResponsesInput)
943	if !ok {
944		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
945	}
946	if err := validateOpGetRouteResponsesInput(input); err != nil {
947		return out, metadata, err
948	}
949	return next.HandleInitialize(ctx, in)
950}
951
952type validateOpGetRoutes struct {
953}
954
955func (*validateOpGetRoutes) ID() string {
956	return "OperationInputValidation"
957}
958
959func (m *validateOpGetRoutes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
960	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
961) {
962	input, ok := in.Parameters.(*GetRoutesInput)
963	if !ok {
964		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
965	}
966	if err := validateOpGetRoutesInput(input); err != nil {
967		return out, metadata, err
968	}
969	return next.HandleInitialize(ctx, in)
970}
971
972type validateOpGetStage struct {
973}
974
975func (*validateOpGetStage) ID() string {
976	return "OperationInputValidation"
977}
978
979func (m *validateOpGetStage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
980	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
981) {
982	input, ok := in.Parameters.(*GetStageInput)
983	if !ok {
984		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
985	}
986	if err := validateOpGetStageInput(input); err != nil {
987		return out, metadata, err
988	}
989	return next.HandleInitialize(ctx, in)
990}
991
992type validateOpGetStages struct {
993}
994
995func (*validateOpGetStages) ID() string {
996	return "OperationInputValidation"
997}
998
999func (m *validateOpGetStages) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1000	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1001) {
1002	input, ok := in.Parameters.(*GetStagesInput)
1003	if !ok {
1004		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1005	}
1006	if err := validateOpGetStagesInput(input); err != nil {
1007		return out, metadata, err
1008	}
1009	return next.HandleInitialize(ctx, in)
1010}
1011
1012type validateOpGetTags struct {
1013}
1014
1015func (*validateOpGetTags) ID() string {
1016	return "OperationInputValidation"
1017}
1018
1019func (m *validateOpGetTags) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1020	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1021) {
1022	input, ok := in.Parameters.(*GetTagsInput)
1023	if !ok {
1024		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1025	}
1026	if err := validateOpGetTagsInput(input); err != nil {
1027		return out, metadata, err
1028	}
1029	return next.HandleInitialize(ctx, in)
1030}
1031
1032type validateOpGetVpcLink struct {
1033}
1034
1035func (*validateOpGetVpcLink) ID() string {
1036	return "OperationInputValidation"
1037}
1038
1039func (m *validateOpGetVpcLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1040	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1041) {
1042	input, ok := in.Parameters.(*GetVpcLinkInput)
1043	if !ok {
1044		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1045	}
1046	if err := validateOpGetVpcLinkInput(input); err != nil {
1047		return out, metadata, err
1048	}
1049	return next.HandleInitialize(ctx, in)
1050}
1051
1052type validateOpImportApi struct {
1053}
1054
1055func (*validateOpImportApi) ID() string {
1056	return "OperationInputValidation"
1057}
1058
1059func (m *validateOpImportApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1060	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1061) {
1062	input, ok := in.Parameters.(*ImportApiInput)
1063	if !ok {
1064		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1065	}
1066	if err := validateOpImportApiInput(input); err != nil {
1067		return out, metadata, err
1068	}
1069	return next.HandleInitialize(ctx, in)
1070}
1071
1072type validateOpReimportApi struct {
1073}
1074
1075func (*validateOpReimportApi) ID() string {
1076	return "OperationInputValidation"
1077}
1078
1079func (m *validateOpReimportApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1080	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1081) {
1082	input, ok := in.Parameters.(*ReimportApiInput)
1083	if !ok {
1084		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1085	}
1086	if err := validateOpReimportApiInput(input); err != nil {
1087		return out, metadata, err
1088	}
1089	return next.HandleInitialize(ctx, in)
1090}
1091
1092type validateOpResetAuthorizersCache struct {
1093}
1094
1095func (*validateOpResetAuthorizersCache) ID() string {
1096	return "OperationInputValidation"
1097}
1098
1099func (m *validateOpResetAuthorizersCache) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1100	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1101) {
1102	input, ok := in.Parameters.(*ResetAuthorizersCacheInput)
1103	if !ok {
1104		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1105	}
1106	if err := validateOpResetAuthorizersCacheInput(input); err != nil {
1107		return out, metadata, err
1108	}
1109	return next.HandleInitialize(ctx, in)
1110}
1111
1112type validateOpTagResource struct {
1113}
1114
1115func (*validateOpTagResource) ID() string {
1116	return "OperationInputValidation"
1117}
1118
1119func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1120	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1121) {
1122	input, ok := in.Parameters.(*TagResourceInput)
1123	if !ok {
1124		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1125	}
1126	if err := validateOpTagResourceInput(input); err != nil {
1127		return out, metadata, err
1128	}
1129	return next.HandleInitialize(ctx, in)
1130}
1131
1132type validateOpUntagResource struct {
1133}
1134
1135func (*validateOpUntagResource) ID() string {
1136	return "OperationInputValidation"
1137}
1138
1139func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1140	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1141) {
1142	input, ok := in.Parameters.(*UntagResourceInput)
1143	if !ok {
1144		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1145	}
1146	if err := validateOpUntagResourceInput(input); err != nil {
1147		return out, metadata, err
1148	}
1149	return next.HandleInitialize(ctx, in)
1150}
1151
1152type validateOpUpdateApi struct {
1153}
1154
1155func (*validateOpUpdateApi) ID() string {
1156	return "OperationInputValidation"
1157}
1158
1159func (m *validateOpUpdateApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1160	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1161) {
1162	input, ok := in.Parameters.(*UpdateApiInput)
1163	if !ok {
1164		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1165	}
1166	if err := validateOpUpdateApiInput(input); err != nil {
1167		return out, metadata, err
1168	}
1169	return next.HandleInitialize(ctx, in)
1170}
1171
1172type validateOpUpdateApiMapping struct {
1173}
1174
1175func (*validateOpUpdateApiMapping) ID() string {
1176	return "OperationInputValidation"
1177}
1178
1179func (m *validateOpUpdateApiMapping) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1180	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1181) {
1182	input, ok := in.Parameters.(*UpdateApiMappingInput)
1183	if !ok {
1184		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1185	}
1186	if err := validateOpUpdateApiMappingInput(input); err != nil {
1187		return out, metadata, err
1188	}
1189	return next.HandleInitialize(ctx, in)
1190}
1191
1192type validateOpUpdateAuthorizer struct {
1193}
1194
1195func (*validateOpUpdateAuthorizer) ID() string {
1196	return "OperationInputValidation"
1197}
1198
1199func (m *validateOpUpdateAuthorizer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1200	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1201) {
1202	input, ok := in.Parameters.(*UpdateAuthorizerInput)
1203	if !ok {
1204		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1205	}
1206	if err := validateOpUpdateAuthorizerInput(input); err != nil {
1207		return out, metadata, err
1208	}
1209	return next.HandleInitialize(ctx, in)
1210}
1211
1212type validateOpUpdateDeployment struct {
1213}
1214
1215func (*validateOpUpdateDeployment) ID() string {
1216	return "OperationInputValidation"
1217}
1218
1219func (m *validateOpUpdateDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1220	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1221) {
1222	input, ok := in.Parameters.(*UpdateDeploymentInput)
1223	if !ok {
1224		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1225	}
1226	if err := validateOpUpdateDeploymentInput(input); err != nil {
1227		return out, metadata, err
1228	}
1229	return next.HandleInitialize(ctx, in)
1230}
1231
1232type validateOpUpdateDomainName struct {
1233}
1234
1235func (*validateOpUpdateDomainName) ID() string {
1236	return "OperationInputValidation"
1237}
1238
1239func (m *validateOpUpdateDomainName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1240	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1241) {
1242	input, ok := in.Parameters.(*UpdateDomainNameInput)
1243	if !ok {
1244		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1245	}
1246	if err := validateOpUpdateDomainNameInput(input); err != nil {
1247		return out, metadata, err
1248	}
1249	return next.HandleInitialize(ctx, in)
1250}
1251
1252type validateOpUpdateIntegration struct {
1253}
1254
1255func (*validateOpUpdateIntegration) ID() string {
1256	return "OperationInputValidation"
1257}
1258
1259func (m *validateOpUpdateIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1260	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1261) {
1262	input, ok := in.Parameters.(*UpdateIntegrationInput)
1263	if !ok {
1264		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1265	}
1266	if err := validateOpUpdateIntegrationInput(input); err != nil {
1267		return out, metadata, err
1268	}
1269	return next.HandleInitialize(ctx, in)
1270}
1271
1272type validateOpUpdateIntegrationResponse struct {
1273}
1274
1275func (*validateOpUpdateIntegrationResponse) ID() string {
1276	return "OperationInputValidation"
1277}
1278
1279func (m *validateOpUpdateIntegrationResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1280	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1281) {
1282	input, ok := in.Parameters.(*UpdateIntegrationResponseInput)
1283	if !ok {
1284		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1285	}
1286	if err := validateOpUpdateIntegrationResponseInput(input); err != nil {
1287		return out, metadata, err
1288	}
1289	return next.HandleInitialize(ctx, in)
1290}
1291
1292type validateOpUpdateModel struct {
1293}
1294
1295func (*validateOpUpdateModel) ID() string {
1296	return "OperationInputValidation"
1297}
1298
1299func (m *validateOpUpdateModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1300	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1301) {
1302	input, ok := in.Parameters.(*UpdateModelInput)
1303	if !ok {
1304		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1305	}
1306	if err := validateOpUpdateModelInput(input); err != nil {
1307		return out, metadata, err
1308	}
1309	return next.HandleInitialize(ctx, in)
1310}
1311
1312type validateOpUpdateRoute struct {
1313}
1314
1315func (*validateOpUpdateRoute) ID() string {
1316	return "OperationInputValidation"
1317}
1318
1319func (m *validateOpUpdateRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1320	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1321) {
1322	input, ok := in.Parameters.(*UpdateRouteInput)
1323	if !ok {
1324		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1325	}
1326	if err := validateOpUpdateRouteInput(input); err != nil {
1327		return out, metadata, err
1328	}
1329	return next.HandleInitialize(ctx, in)
1330}
1331
1332type validateOpUpdateRouteResponse struct {
1333}
1334
1335func (*validateOpUpdateRouteResponse) ID() string {
1336	return "OperationInputValidation"
1337}
1338
1339func (m *validateOpUpdateRouteResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1340	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1341) {
1342	input, ok := in.Parameters.(*UpdateRouteResponseInput)
1343	if !ok {
1344		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1345	}
1346	if err := validateOpUpdateRouteResponseInput(input); err != nil {
1347		return out, metadata, err
1348	}
1349	return next.HandleInitialize(ctx, in)
1350}
1351
1352type validateOpUpdateStage struct {
1353}
1354
1355func (*validateOpUpdateStage) ID() string {
1356	return "OperationInputValidation"
1357}
1358
1359func (m *validateOpUpdateStage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1360	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1361) {
1362	input, ok := in.Parameters.(*UpdateStageInput)
1363	if !ok {
1364		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1365	}
1366	if err := validateOpUpdateStageInput(input); err != nil {
1367		return out, metadata, err
1368	}
1369	return next.HandleInitialize(ctx, in)
1370}
1371
1372type validateOpUpdateVpcLink struct {
1373}
1374
1375func (*validateOpUpdateVpcLink) ID() string {
1376	return "OperationInputValidation"
1377}
1378
1379func (m *validateOpUpdateVpcLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1380	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1381) {
1382	input, ok := in.Parameters.(*UpdateVpcLinkInput)
1383	if !ok {
1384		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1385	}
1386	if err := validateOpUpdateVpcLinkInput(input); err != nil {
1387		return out, metadata, err
1388	}
1389	return next.HandleInitialize(ctx, in)
1390}
1391
1392func addOpCreateApiValidationMiddleware(stack *middleware.Stack) error {
1393	return stack.Initialize.Add(&validateOpCreateApi{}, middleware.After)
1394}
1395
1396func addOpCreateApiMappingValidationMiddleware(stack *middleware.Stack) error {
1397	return stack.Initialize.Add(&validateOpCreateApiMapping{}, middleware.After)
1398}
1399
1400func addOpCreateAuthorizerValidationMiddleware(stack *middleware.Stack) error {
1401	return stack.Initialize.Add(&validateOpCreateAuthorizer{}, middleware.After)
1402}
1403
1404func addOpCreateDeploymentValidationMiddleware(stack *middleware.Stack) error {
1405	return stack.Initialize.Add(&validateOpCreateDeployment{}, middleware.After)
1406}
1407
1408func addOpCreateDomainNameValidationMiddleware(stack *middleware.Stack) error {
1409	return stack.Initialize.Add(&validateOpCreateDomainName{}, middleware.After)
1410}
1411
1412func addOpCreateIntegrationValidationMiddleware(stack *middleware.Stack) error {
1413	return stack.Initialize.Add(&validateOpCreateIntegration{}, middleware.After)
1414}
1415
1416func addOpCreateIntegrationResponseValidationMiddleware(stack *middleware.Stack) error {
1417	return stack.Initialize.Add(&validateOpCreateIntegrationResponse{}, middleware.After)
1418}
1419
1420func addOpCreateModelValidationMiddleware(stack *middleware.Stack) error {
1421	return stack.Initialize.Add(&validateOpCreateModel{}, middleware.After)
1422}
1423
1424func addOpCreateRouteValidationMiddleware(stack *middleware.Stack) error {
1425	return stack.Initialize.Add(&validateOpCreateRoute{}, middleware.After)
1426}
1427
1428func addOpCreateRouteResponseValidationMiddleware(stack *middleware.Stack) error {
1429	return stack.Initialize.Add(&validateOpCreateRouteResponse{}, middleware.After)
1430}
1431
1432func addOpCreateStageValidationMiddleware(stack *middleware.Stack) error {
1433	return stack.Initialize.Add(&validateOpCreateStage{}, middleware.After)
1434}
1435
1436func addOpCreateVpcLinkValidationMiddleware(stack *middleware.Stack) error {
1437	return stack.Initialize.Add(&validateOpCreateVpcLink{}, middleware.After)
1438}
1439
1440func addOpDeleteAccessLogSettingsValidationMiddleware(stack *middleware.Stack) error {
1441	return stack.Initialize.Add(&validateOpDeleteAccessLogSettings{}, middleware.After)
1442}
1443
1444func addOpDeleteApiValidationMiddleware(stack *middleware.Stack) error {
1445	return stack.Initialize.Add(&validateOpDeleteApi{}, middleware.After)
1446}
1447
1448func addOpDeleteApiMappingValidationMiddleware(stack *middleware.Stack) error {
1449	return stack.Initialize.Add(&validateOpDeleteApiMapping{}, middleware.After)
1450}
1451
1452func addOpDeleteAuthorizerValidationMiddleware(stack *middleware.Stack) error {
1453	return stack.Initialize.Add(&validateOpDeleteAuthorizer{}, middleware.After)
1454}
1455
1456func addOpDeleteCorsConfigurationValidationMiddleware(stack *middleware.Stack) error {
1457	return stack.Initialize.Add(&validateOpDeleteCorsConfiguration{}, middleware.After)
1458}
1459
1460func addOpDeleteDeploymentValidationMiddleware(stack *middleware.Stack) error {
1461	return stack.Initialize.Add(&validateOpDeleteDeployment{}, middleware.After)
1462}
1463
1464func addOpDeleteDomainNameValidationMiddleware(stack *middleware.Stack) error {
1465	return stack.Initialize.Add(&validateOpDeleteDomainName{}, middleware.After)
1466}
1467
1468func addOpDeleteIntegrationValidationMiddleware(stack *middleware.Stack) error {
1469	return stack.Initialize.Add(&validateOpDeleteIntegration{}, middleware.After)
1470}
1471
1472func addOpDeleteIntegrationResponseValidationMiddleware(stack *middleware.Stack) error {
1473	return stack.Initialize.Add(&validateOpDeleteIntegrationResponse{}, middleware.After)
1474}
1475
1476func addOpDeleteModelValidationMiddleware(stack *middleware.Stack) error {
1477	return stack.Initialize.Add(&validateOpDeleteModel{}, middleware.After)
1478}
1479
1480func addOpDeleteRouteValidationMiddleware(stack *middleware.Stack) error {
1481	return stack.Initialize.Add(&validateOpDeleteRoute{}, middleware.After)
1482}
1483
1484func addOpDeleteRouteRequestParameterValidationMiddleware(stack *middleware.Stack) error {
1485	return stack.Initialize.Add(&validateOpDeleteRouteRequestParameter{}, middleware.After)
1486}
1487
1488func addOpDeleteRouteResponseValidationMiddleware(stack *middleware.Stack) error {
1489	return stack.Initialize.Add(&validateOpDeleteRouteResponse{}, middleware.After)
1490}
1491
1492func addOpDeleteRouteSettingsValidationMiddleware(stack *middleware.Stack) error {
1493	return stack.Initialize.Add(&validateOpDeleteRouteSettings{}, middleware.After)
1494}
1495
1496func addOpDeleteStageValidationMiddleware(stack *middleware.Stack) error {
1497	return stack.Initialize.Add(&validateOpDeleteStage{}, middleware.After)
1498}
1499
1500func addOpDeleteVpcLinkValidationMiddleware(stack *middleware.Stack) error {
1501	return stack.Initialize.Add(&validateOpDeleteVpcLink{}, middleware.After)
1502}
1503
1504func addOpExportApiValidationMiddleware(stack *middleware.Stack) error {
1505	return stack.Initialize.Add(&validateOpExportApi{}, middleware.After)
1506}
1507
1508func addOpGetApiValidationMiddleware(stack *middleware.Stack) error {
1509	return stack.Initialize.Add(&validateOpGetApi{}, middleware.After)
1510}
1511
1512func addOpGetApiMappingValidationMiddleware(stack *middleware.Stack) error {
1513	return stack.Initialize.Add(&validateOpGetApiMapping{}, middleware.After)
1514}
1515
1516func addOpGetApiMappingsValidationMiddleware(stack *middleware.Stack) error {
1517	return stack.Initialize.Add(&validateOpGetApiMappings{}, middleware.After)
1518}
1519
1520func addOpGetAuthorizerValidationMiddleware(stack *middleware.Stack) error {
1521	return stack.Initialize.Add(&validateOpGetAuthorizer{}, middleware.After)
1522}
1523
1524func addOpGetAuthorizersValidationMiddleware(stack *middleware.Stack) error {
1525	return stack.Initialize.Add(&validateOpGetAuthorizers{}, middleware.After)
1526}
1527
1528func addOpGetDeploymentValidationMiddleware(stack *middleware.Stack) error {
1529	return stack.Initialize.Add(&validateOpGetDeployment{}, middleware.After)
1530}
1531
1532func addOpGetDeploymentsValidationMiddleware(stack *middleware.Stack) error {
1533	return stack.Initialize.Add(&validateOpGetDeployments{}, middleware.After)
1534}
1535
1536func addOpGetDomainNameValidationMiddleware(stack *middleware.Stack) error {
1537	return stack.Initialize.Add(&validateOpGetDomainName{}, middleware.After)
1538}
1539
1540func addOpGetIntegrationValidationMiddleware(stack *middleware.Stack) error {
1541	return stack.Initialize.Add(&validateOpGetIntegration{}, middleware.After)
1542}
1543
1544func addOpGetIntegrationResponseValidationMiddleware(stack *middleware.Stack) error {
1545	return stack.Initialize.Add(&validateOpGetIntegrationResponse{}, middleware.After)
1546}
1547
1548func addOpGetIntegrationResponsesValidationMiddleware(stack *middleware.Stack) error {
1549	return stack.Initialize.Add(&validateOpGetIntegrationResponses{}, middleware.After)
1550}
1551
1552func addOpGetIntegrationsValidationMiddleware(stack *middleware.Stack) error {
1553	return stack.Initialize.Add(&validateOpGetIntegrations{}, middleware.After)
1554}
1555
1556func addOpGetModelValidationMiddleware(stack *middleware.Stack) error {
1557	return stack.Initialize.Add(&validateOpGetModel{}, middleware.After)
1558}
1559
1560func addOpGetModelsValidationMiddleware(stack *middleware.Stack) error {
1561	return stack.Initialize.Add(&validateOpGetModels{}, middleware.After)
1562}
1563
1564func addOpGetModelTemplateValidationMiddleware(stack *middleware.Stack) error {
1565	return stack.Initialize.Add(&validateOpGetModelTemplate{}, middleware.After)
1566}
1567
1568func addOpGetRouteValidationMiddleware(stack *middleware.Stack) error {
1569	return stack.Initialize.Add(&validateOpGetRoute{}, middleware.After)
1570}
1571
1572func addOpGetRouteResponseValidationMiddleware(stack *middleware.Stack) error {
1573	return stack.Initialize.Add(&validateOpGetRouteResponse{}, middleware.After)
1574}
1575
1576func addOpGetRouteResponsesValidationMiddleware(stack *middleware.Stack) error {
1577	return stack.Initialize.Add(&validateOpGetRouteResponses{}, middleware.After)
1578}
1579
1580func addOpGetRoutesValidationMiddleware(stack *middleware.Stack) error {
1581	return stack.Initialize.Add(&validateOpGetRoutes{}, middleware.After)
1582}
1583
1584func addOpGetStageValidationMiddleware(stack *middleware.Stack) error {
1585	return stack.Initialize.Add(&validateOpGetStage{}, middleware.After)
1586}
1587
1588func addOpGetStagesValidationMiddleware(stack *middleware.Stack) error {
1589	return stack.Initialize.Add(&validateOpGetStages{}, middleware.After)
1590}
1591
1592func addOpGetTagsValidationMiddleware(stack *middleware.Stack) error {
1593	return stack.Initialize.Add(&validateOpGetTags{}, middleware.After)
1594}
1595
1596func addOpGetVpcLinkValidationMiddleware(stack *middleware.Stack) error {
1597	return stack.Initialize.Add(&validateOpGetVpcLink{}, middleware.After)
1598}
1599
1600func addOpImportApiValidationMiddleware(stack *middleware.Stack) error {
1601	return stack.Initialize.Add(&validateOpImportApi{}, middleware.After)
1602}
1603
1604func addOpReimportApiValidationMiddleware(stack *middleware.Stack) error {
1605	return stack.Initialize.Add(&validateOpReimportApi{}, middleware.After)
1606}
1607
1608func addOpResetAuthorizersCacheValidationMiddleware(stack *middleware.Stack) error {
1609	return stack.Initialize.Add(&validateOpResetAuthorizersCache{}, middleware.After)
1610}
1611
1612func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
1613	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
1614}
1615
1616func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
1617	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
1618}
1619
1620func addOpUpdateApiValidationMiddleware(stack *middleware.Stack) error {
1621	return stack.Initialize.Add(&validateOpUpdateApi{}, middleware.After)
1622}
1623
1624func addOpUpdateApiMappingValidationMiddleware(stack *middleware.Stack) error {
1625	return stack.Initialize.Add(&validateOpUpdateApiMapping{}, middleware.After)
1626}
1627
1628func addOpUpdateAuthorizerValidationMiddleware(stack *middleware.Stack) error {
1629	return stack.Initialize.Add(&validateOpUpdateAuthorizer{}, middleware.After)
1630}
1631
1632func addOpUpdateDeploymentValidationMiddleware(stack *middleware.Stack) error {
1633	return stack.Initialize.Add(&validateOpUpdateDeployment{}, middleware.After)
1634}
1635
1636func addOpUpdateDomainNameValidationMiddleware(stack *middleware.Stack) error {
1637	return stack.Initialize.Add(&validateOpUpdateDomainName{}, middleware.After)
1638}
1639
1640func addOpUpdateIntegrationValidationMiddleware(stack *middleware.Stack) error {
1641	return stack.Initialize.Add(&validateOpUpdateIntegration{}, middleware.After)
1642}
1643
1644func addOpUpdateIntegrationResponseValidationMiddleware(stack *middleware.Stack) error {
1645	return stack.Initialize.Add(&validateOpUpdateIntegrationResponse{}, middleware.After)
1646}
1647
1648func addOpUpdateModelValidationMiddleware(stack *middleware.Stack) error {
1649	return stack.Initialize.Add(&validateOpUpdateModel{}, middleware.After)
1650}
1651
1652func addOpUpdateRouteValidationMiddleware(stack *middleware.Stack) error {
1653	return stack.Initialize.Add(&validateOpUpdateRoute{}, middleware.After)
1654}
1655
1656func addOpUpdateRouteResponseValidationMiddleware(stack *middleware.Stack) error {
1657	return stack.Initialize.Add(&validateOpUpdateRouteResponse{}, middleware.After)
1658}
1659
1660func addOpUpdateStageValidationMiddleware(stack *middleware.Stack) error {
1661	return stack.Initialize.Add(&validateOpUpdateStage{}, middleware.After)
1662}
1663
1664func addOpUpdateVpcLinkValidationMiddleware(stack *middleware.Stack) error {
1665	return stack.Initialize.Add(&validateOpUpdateVpcLink{}, middleware.After)
1666}
1667
1668func validateOpCreateApiInput(v *CreateApiInput) error {
1669	if v == nil {
1670		return nil
1671	}
1672	invalidParams := smithy.InvalidParamsError{Context: "CreateApiInput"}
1673	if v.Name == nil {
1674		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1675	}
1676	if len(v.ProtocolType) == 0 {
1677		invalidParams.Add(smithy.NewErrParamRequired("ProtocolType"))
1678	}
1679	if invalidParams.Len() > 0 {
1680		return invalidParams
1681	} else {
1682		return nil
1683	}
1684}
1685
1686func validateOpCreateApiMappingInput(v *CreateApiMappingInput) error {
1687	if v == nil {
1688		return nil
1689	}
1690	invalidParams := smithy.InvalidParamsError{Context: "CreateApiMappingInput"}
1691	if v.ApiId == nil {
1692		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
1693	}
1694	if v.DomainName == nil {
1695		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1696	}
1697	if v.Stage == nil {
1698		invalidParams.Add(smithy.NewErrParamRequired("Stage"))
1699	}
1700	if invalidParams.Len() > 0 {
1701		return invalidParams
1702	} else {
1703		return nil
1704	}
1705}
1706
1707func validateOpCreateAuthorizerInput(v *CreateAuthorizerInput) error {
1708	if v == nil {
1709		return nil
1710	}
1711	invalidParams := smithy.InvalidParamsError{Context: "CreateAuthorizerInput"}
1712	if v.ApiId == nil {
1713		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
1714	}
1715	if len(v.AuthorizerType) == 0 {
1716		invalidParams.Add(smithy.NewErrParamRequired("AuthorizerType"))
1717	}
1718	if v.IdentitySource == nil {
1719		invalidParams.Add(smithy.NewErrParamRequired("IdentitySource"))
1720	}
1721	if v.Name == nil {
1722		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1723	}
1724	if invalidParams.Len() > 0 {
1725		return invalidParams
1726	} else {
1727		return nil
1728	}
1729}
1730
1731func validateOpCreateDeploymentInput(v *CreateDeploymentInput) error {
1732	if v == nil {
1733		return nil
1734	}
1735	invalidParams := smithy.InvalidParamsError{Context: "CreateDeploymentInput"}
1736	if v.ApiId == nil {
1737		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
1738	}
1739	if invalidParams.Len() > 0 {
1740		return invalidParams
1741	} else {
1742		return nil
1743	}
1744}
1745
1746func validateOpCreateDomainNameInput(v *CreateDomainNameInput) error {
1747	if v == nil {
1748		return nil
1749	}
1750	invalidParams := smithy.InvalidParamsError{Context: "CreateDomainNameInput"}
1751	if v.DomainName == nil {
1752		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1753	}
1754	if invalidParams.Len() > 0 {
1755		return invalidParams
1756	} else {
1757		return nil
1758	}
1759}
1760
1761func validateOpCreateIntegrationInput(v *CreateIntegrationInput) error {
1762	if v == nil {
1763		return nil
1764	}
1765	invalidParams := smithy.InvalidParamsError{Context: "CreateIntegrationInput"}
1766	if v.ApiId == nil {
1767		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
1768	}
1769	if len(v.IntegrationType) == 0 {
1770		invalidParams.Add(smithy.NewErrParamRequired("IntegrationType"))
1771	}
1772	if invalidParams.Len() > 0 {
1773		return invalidParams
1774	} else {
1775		return nil
1776	}
1777}
1778
1779func validateOpCreateIntegrationResponseInput(v *CreateIntegrationResponseInput) error {
1780	if v == nil {
1781		return nil
1782	}
1783	invalidParams := smithy.InvalidParamsError{Context: "CreateIntegrationResponseInput"}
1784	if v.ApiId == nil {
1785		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
1786	}
1787	if v.IntegrationId == nil {
1788		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
1789	}
1790	if v.IntegrationResponseKey == nil {
1791		invalidParams.Add(smithy.NewErrParamRequired("IntegrationResponseKey"))
1792	}
1793	if invalidParams.Len() > 0 {
1794		return invalidParams
1795	} else {
1796		return nil
1797	}
1798}
1799
1800func validateOpCreateModelInput(v *CreateModelInput) error {
1801	if v == nil {
1802		return nil
1803	}
1804	invalidParams := smithy.InvalidParamsError{Context: "CreateModelInput"}
1805	if v.ApiId == nil {
1806		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
1807	}
1808	if v.Name == nil {
1809		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1810	}
1811	if v.Schema == nil {
1812		invalidParams.Add(smithy.NewErrParamRequired("Schema"))
1813	}
1814	if invalidParams.Len() > 0 {
1815		return invalidParams
1816	} else {
1817		return nil
1818	}
1819}
1820
1821func validateOpCreateRouteInput(v *CreateRouteInput) error {
1822	if v == nil {
1823		return nil
1824	}
1825	invalidParams := smithy.InvalidParamsError{Context: "CreateRouteInput"}
1826	if v.ApiId == nil {
1827		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
1828	}
1829	if v.RouteKey == nil {
1830		invalidParams.Add(smithy.NewErrParamRequired("RouteKey"))
1831	}
1832	if invalidParams.Len() > 0 {
1833		return invalidParams
1834	} else {
1835		return nil
1836	}
1837}
1838
1839func validateOpCreateRouteResponseInput(v *CreateRouteResponseInput) error {
1840	if v == nil {
1841		return nil
1842	}
1843	invalidParams := smithy.InvalidParamsError{Context: "CreateRouteResponseInput"}
1844	if v.ApiId == nil {
1845		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
1846	}
1847	if v.RouteId == nil {
1848		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
1849	}
1850	if v.RouteResponseKey == nil {
1851		invalidParams.Add(smithy.NewErrParamRequired("RouteResponseKey"))
1852	}
1853	if invalidParams.Len() > 0 {
1854		return invalidParams
1855	} else {
1856		return nil
1857	}
1858}
1859
1860func validateOpCreateStageInput(v *CreateStageInput) error {
1861	if v == nil {
1862		return nil
1863	}
1864	invalidParams := smithy.InvalidParamsError{Context: "CreateStageInput"}
1865	if v.ApiId == nil {
1866		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
1867	}
1868	if v.StageName == nil {
1869		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
1870	}
1871	if invalidParams.Len() > 0 {
1872		return invalidParams
1873	} else {
1874		return nil
1875	}
1876}
1877
1878func validateOpCreateVpcLinkInput(v *CreateVpcLinkInput) error {
1879	if v == nil {
1880		return nil
1881	}
1882	invalidParams := smithy.InvalidParamsError{Context: "CreateVpcLinkInput"}
1883	if v.Name == nil {
1884		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1885	}
1886	if v.SubnetIds == nil {
1887		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
1888	}
1889	if invalidParams.Len() > 0 {
1890		return invalidParams
1891	} else {
1892		return nil
1893	}
1894}
1895
1896func validateOpDeleteAccessLogSettingsInput(v *DeleteAccessLogSettingsInput) error {
1897	if v == nil {
1898		return nil
1899	}
1900	invalidParams := smithy.InvalidParamsError{Context: "DeleteAccessLogSettingsInput"}
1901	if v.ApiId == nil {
1902		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
1903	}
1904	if v.StageName == nil {
1905		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
1906	}
1907	if invalidParams.Len() > 0 {
1908		return invalidParams
1909	} else {
1910		return nil
1911	}
1912}
1913
1914func validateOpDeleteApiInput(v *DeleteApiInput) error {
1915	if v == nil {
1916		return nil
1917	}
1918	invalidParams := smithy.InvalidParamsError{Context: "DeleteApiInput"}
1919	if v.ApiId == nil {
1920		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
1921	}
1922	if invalidParams.Len() > 0 {
1923		return invalidParams
1924	} else {
1925		return nil
1926	}
1927}
1928
1929func validateOpDeleteApiMappingInput(v *DeleteApiMappingInput) error {
1930	if v == nil {
1931		return nil
1932	}
1933	invalidParams := smithy.InvalidParamsError{Context: "DeleteApiMappingInput"}
1934	if v.ApiMappingId == nil {
1935		invalidParams.Add(smithy.NewErrParamRequired("ApiMappingId"))
1936	}
1937	if v.DomainName == nil {
1938		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
1939	}
1940	if invalidParams.Len() > 0 {
1941		return invalidParams
1942	} else {
1943		return nil
1944	}
1945}
1946
1947func validateOpDeleteAuthorizerInput(v *DeleteAuthorizerInput) error {
1948	if v == nil {
1949		return nil
1950	}
1951	invalidParams := smithy.InvalidParamsError{Context: "DeleteAuthorizerInput"}
1952	if v.ApiId == nil {
1953		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
1954	}
1955	if v.AuthorizerId == nil {
1956		invalidParams.Add(smithy.NewErrParamRequired("AuthorizerId"))
1957	}
1958	if invalidParams.Len() > 0 {
1959		return invalidParams
1960	} else {
1961		return nil
1962	}
1963}
1964
1965func validateOpDeleteCorsConfigurationInput(v *DeleteCorsConfigurationInput) error {
1966	if v == nil {
1967		return nil
1968	}
1969	invalidParams := smithy.InvalidParamsError{Context: "DeleteCorsConfigurationInput"}
1970	if v.ApiId == nil {
1971		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
1972	}
1973	if invalidParams.Len() > 0 {
1974		return invalidParams
1975	} else {
1976		return nil
1977	}
1978}
1979
1980func validateOpDeleteDeploymentInput(v *DeleteDeploymentInput) error {
1981	if v == nil {
1982		return nil
1983	}
1984	invalidParams := smithy.InvalidParamsError{Context: "DeleteDeploymentInput"}
1985	if v.ApiId == nil {
1986		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
1987	}
1988	if v.DeploymentId == nil {
1989		invalidParams.Add(smithy.NewErrParamRequired("DeploymentId"))
1990	}
1991	if invalidParams.Len() > 0 {
1992		return invalidParams
1993	} else {
1994		return nil
1995	}
1996}
1997
1998func validateOpDeleteDomainNameInput(v *DeleteDomainNameInput) error {
1999	if v == nil {
2000		return nil
2001	}
2002	invalidParams := smithy.InvalidParamsError{Context: "DeleteDomainNameInput"}
2003	if v.DomainName == nil {
2004		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
2005	}
2006	if invalidParams.Len() > 0 {
2007		return invalidParams
2008	} else {
2009		return nil
2010	}
2011}
2012
2013func validateOpDeleteIntegrationInput(v *DeleteIntegrationInput) error {
2014	if v == nil {
2015		return nil
2016	}
2017	invalidParams := smithy.InvalidParamsError{Context: "DeleteIntegrationInput"}
2018	if v.ApiId == nil {
2019		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2020	}
2021	if v.IntegrationId == nil {
2022		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
2023	}
2024	if invalidParams.Len() > 0 {
2025		return invalidParams
2026	} else {
2027		return nil
2028	}
2029}
2030
2031func validateOpDeleteIntegrationResponseInput(v *DeleteIntegrationResponseInput) error {
2032	if v == nil {
2033		return nil
2034	}
2035	invalidParams := smithy.InvalidParamsError{Context: "DeleteIntegrationResponseInput"}
2036	if v.ApiId == nil {
2037		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2038	}
2039	if v.IntegrationId == nil {
2040		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
2041	}
2042	if v.IntegrationResponseId == nil {
2043		invalidParams.Add(smithy.NewErrParamRequired("IntegrationResponseId"))
2044	}
2045	if invalidParams.Len() > 0 {
2046		return invalidParams
2047	} else {
2048		return nil
2049	}
2050}
2051
2052func validateOpDeleteModelInput(v *DeleteModelInput) error {
2053	if v == nil {
2054		return nil
2055	}
2056	invalidParams := smithy.InvalidParamsError{Context: "DeleteModelInput"}
2057	if v.ApiId == nil {
2058		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2059	}
2060	if v.ModelId == nil {
2061		invalidParams.Add(smithy.NewErrParamRequired("ModelId"))
2062	}
2063	if invalidParams.Len() > 0 {
2064		return invalidParams
2065	} else {
2066		return nil
2067	}
2068}
2069
2070func validateOpDeleteRouteInput(v *DeleteRouteInput) error {
2071	if v == nil {
2072		return nil
2073	}
2074	invalidParams := smithy.InvalidParamsError{Context: "DeleteRouteInput"}
2075	if v.ApiId == nil {
2076		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2077	}
2078	if v.RouteId == nil {
2079		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
2080	}
2081	if invalidParams.Len() > 0 {
2082		return invalidParams
2083	} else {
2084		return nil
2085	}
2086}
2087
2088func validateOpDeleteRouteRequestParameterInput(v *DeleteRouteRequestParameterInput) error {
2089	if v == nil {
2090		return nil
2091	}
2092	invalidParams := smithy.InvalidParamsError{Context: "DeleteRouteRequestParameterInput"}
2093	if v.ApiId == nil {
2094		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2095	}
2096	if v.RequestParameterKey == nil {
2097		invalidParams.Add(smithy.NewErrParamRequired("RequestParameterKey"))
2098	}
2099	if v.RouteId == nil {
2100		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
2101	}
2102	if invalidParams.Len() > 0 {
2103		return invalidParams
2104	} else {
2105		return nil
2106	}
2107}
2108
2109func validateOpDeleteRouteResponseInput(v *DeleteRouteResponseInput) error {
2110	if v == nil {
2111		return nil
2112	}
2113	invalidParams := smithy.InvalidParamsError{Context: "DeleteRouteResponseInput"}
2114	if v.ApiId == nil {
2115		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2116	}
2117	if v.RouteId == nil {
2118		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
2119	}
2120	if v.RouteResponseId == nil {
2121		invalidParams.Add(smithy.NewErrParamRequired("RouteResponseId"))
2122	}
2123	if invalidParams.Len() > 0 {
2124		return invalidParams
2125	} else {
2126		return nil
2127	}
2128}
2129
2130func validateOpDeleteRouteSettingsInput(v *DeleteRouteSettingsInput) error {
2131	if v == nil {
2132		return nil
2133	}
2134	invalidParams := smithy.InvalidParamsError{Context: "DeleteRouteSettingsInput"}
2135	if v.ApiId == nil {
2136		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2137	}
2138	if v.RouteKey == nil {
2139		invalidParams.Add(smithy.NewErrParamRequired("RouteKey"))
2140	}
2141	if v.StageName == nil {
2142		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
2143	}
2144	if invalidParams.Len() > 0 {
2145		return invalidParams
2146	} else {
2147		return nil
2148	}
2149}
2150
2151func validateOpDeleteStageInput(v *DeleteStageInput) error {
2152	if v == nil {
2153		return nil
2154	}
2155	invalidParams := smithy.InvalidParamsError{Context: "DeleteStageInput"}
2156	if v.ApiId == nil {
2157		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2158	}
2159	if v.StageName == nil {
2160		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
2161	}
2162	if invalidParams.Len() > 0 {
2163		return invalidParams
2164	} else {
2165		return nil
2166	}
2167}
2168
2169func validateOpDeleteVpcLinkInput(v *DeleteVpcLinkInput) error {
2170	if v == nil {
2171		return nil
2172	}
2173	invalidParams := smithy.InvalidParamsError{Context: "DeleteVpcLinkInput"}
2174	if v.VpcLinkId == nil {
2175		invalidParams.Add(smithy.NewErrParamRequired("VpcLinkId"))
2176	}
2177	if invalidParams.Len() > 0 {
2178		return invalidParams
2179	} else {
2180		return nil
2181	}
2182}
2183
2184func validateOpExportApiInput(v *ExportApiInput) error {
2185	if v == nil {
2186		return nil
2187	}
2188	invalidParams := smithy.InvalidParamsError{Context: "ExportApiInput"}
2189	if v.ApiId == nil {
2190		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2191	}
2192	if v.OutputType == nil {
2193		invalidParams.Add(smithy.NewErrParamRequired("OutputType"))
2194	}
2195	if v.Specification == nil {
2196		invalidParams.Add(smithy.NewErrParamRequired("Specification"))
2197	}
2198	if invalidParams.Len() > 0 {
2199		return invalidParams
2200	} else {
2201		return nil
2202	}
2203}
2204
2205func validateOpGetApiInput(v *GetApiInput) error {
2206	if v == nil {
2207		return nil
2208	}
2209	invalidParams := smithy.InvalidParamsError{Context: "GetApiInput"}
2210	if v.ApiId == nil {
2211		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2212	}
2213	if invalidParams.Len() > 0 {
2214		return invalidParams
2215	} else {
2216		return nil
2217	}
2218}
2219
2220func validateOpGetApiMappingInput(v *GetApiMappingInput) error {
2221	if v == nil {
2222		return nil
2223	}
2224	invalidParams := smithy.InvalidParamsError{Context: "GetApiMappingInput"}
2225	if v.ApiMappingId == nil {
2226		invalidParams.Add(smithy.NewErrParamRequired("ApiMappingId"))
2227	}
2228	if v.DomainName == nil {
2229		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
2230	}
2231	if invalidParams.Len() > 0 {
2232		return invalidParams
2233	} else {
2234		return nil
2235	}
2236}
2237
2238func validateOpGetApiMappingsInput(v *GetApiMappingsInput) error {
2239	if v == nil {
2240		return nil
2241	}
2242	invalidParams := smithy.InvalidParamsError{Context: "GetApiMappingsInput"}
2243	if v.DomainName == nil {
2244		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
2245	}
2246	if invalidParams.Len() > 0 {
2247		return invalidParams
2248	} else {
2249		return nil
2250	}
2251}
2252
2253func validateOpGetAuthorizerInput(v *GetAuthorizerInput) error {
2254	if v == nil {
2255		return nil
2256	}
2257	invalidParams := smithy.InvalidParamsError{Context: "GetAuthorizerInput"}
2258	if v.ApiId == nil {
2259		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2260	}
2261	if v.AuthorizerId == nil {
2262		invalidParams.Add(smithy.NewErrParamRequired("AuthorizerId"))
2263	}
2264	if invalidParams.Len() > 0 {
2265		return invalidParams
2266	} else {
2267		return nil
2268	}
2269}
2270
2271func validateOpGetAuthorizersInput(v *GetAuthorizersInput) error {
2272	if v == nil {
2273		return nil
2274	}
2275	invalidParams := smithy.InvalidParamsError{Context: "GetAuthorizersInput"}
2276	if v.ApiId == nil {
2277		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2278	}
2279	if invalidParams.Len() > 0 {
2280		return invalidParams
2281	} else {
2282		return nil
2283	}
2284}
2285
2286func validateOpGetDeploymentInput(v *GetDeploymentInput) error {
2287	if v == nil {
2288		return nil
2289	}
2290	invalidParams := smithy.InvalidParamsError{Context: "GetDeploymentInput"}
2291	if v.ApiId == nil {
2292		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2293	}
2294	if v.DeploymentId == nil {
2295		invalidParams.Add(smithy.NewErrParamRequired("DeploymentId"))
2296	}
2297	if invalidParams.Len() > 0 {
2298		return invalidParams
2299	} else {
2300		return nil
2301	}
2302}
2303
2304func validateOpGetDeploymentsInput(v *GetDeploymentsInput) error {
2305	if v == nil {
2306		return nil
2307	}
2308	invalidParams := smithy.InvalidParamsError{Context: "GetDeploymentsInput"}
2309	if v.ApiId == nil {
2310		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2311	}
2312	if invalidParams.Len() > 0 {
2313		return invalidParams
2314	} else {
2315		return nil
2316	}
2317}
2318
2319func validateOpGetDomainNameInput(v *GetDomainNameInput) error {
2320	if v == nil {
2321		return nil
2322	}
2323	invalidParams := smithy.InvalidParamsError{Context: "GetDomainNameInput"}
2324	if v.DomainName == nil {
2325		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
2326	}
2327	if invalidParams.Len() > 0 {
2328		return invalidParams
2329	} else {
2330		return nil
2331	}
2332}
2333
2334func validateOpGetIntegrationInput(v *GetIntegrationInput) error {
2335	if v == nil {
2336		return nil
2337	}
2338	invalidParams := smithy.InvalidParamsError{Context: "GetIntegrationInput"}
2339	if v.ApiId == nil {
2340		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2341	}
2342	if v.IntegrationId == nil {
2343		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
2344	}
2345	if invalidParams.Len() > 0 {
2346		return invalidParams
2347	} else {
2348		return nil
2349	}
2350}
2351
2352func validateOpGetIntegrationResponseInput(v *GetIntegrationResponseInput) error {
2353	if v == nil {
2354		return nil
2355	}
2356	invalidParams := smithy.InvalidParamsError{Context: "GetIntegrationResponseInput"}
2357	if v.ApiId == nil {
2358		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2359	}
2360	if v.IntegrationId == nil {
2361		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
2362	}
2363	if v.IntegrationResponseId == nil {
2364		invalidParams.Add(smithy.NewErrParamRequired("IntegrationResponseId"))
2365	}
2366	if invalidParams.Len() > 0 {
2367		return invalidParams
2368	} else {
2369		return nil
2370	}
2371}
2372
2373func validateOpGetIntegrationResponsesInput(v *GetIntegrationResponsesInput) error {
2374	if v == nil {
2375		return nil
2376	}
2377	invalidParams := smithy.InvalidParamsError{Context: "GetIntegrationResponsesInput"}
2378	if v.ApiId == nil {
2379		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2380	}
2381	if v.IntegrationId == nil {
2382		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
2383	}
2384	if invalidParams.Len() > 0 {
2385		return invalidParams
2386	} else {
2387		return nil
2388	}
2389}
2390
2391func validateOpGetIntegrationsInput(v *GetIntegrationsInput) error {
2392	if v == nil {
2393		return nil
2394	}
2395	invalidParams := smithy.InvalidParamsError{Context: "GetIntegrationsInput"}
2396	if v.ApiId == nil {
2397		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2398	}
2399	if invalidParams.Len() > 0 {
2400		return invalidParams
2401	} else {
2402		return nil
2403	}
2404}
2405
2406func validateOpGetModelInput(v *GetModelInput) error {
2407	if v == nil {
2408		return nil
2409	}
2410	invalidParams := smithy.InvalidParamsError{Context: "GetModelInput"}
2411	if v.ApiId == nil {
2412		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2413	}
2414	if v.ModelId == nil {
2415		invalidParams.Add(smithy.NewErrParamRequired("ModelId"))
2416	}
2417	if invalidParams.Len() > 0 {
2418		return invalidParams
2419	} else {
2420		return nil
2421	}
2422}
2423
2424func validateOpGetModelsInput(v *GetModelsInput) error {
2425	if v == nil {
2426		return nil
2427	}
2428	invalidParams := smithy.InvalidParamsError{Context: "GetModelsInput"}
2429	if v.ApiId == nil {
2430		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2431	}
2432	if invalidParams.Len() > 0 {
2433		return invalidParams
2434	} else {
2435		return nil
2436	}
2437}
2438
2439func validateOpGetModelTemplateInput(v *GetModelTemplateInput) error {
2440	if v == nil {
2441		return nil
2442	}
2443	invalidParams := smithy.InvalidParamsError{Context: "GetModelTemplateInput"}
2444	if v.ApiId == nil {
2445		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2446	}
2447	if v.ModelId == nil {
2448		invalidParams.Add(smithy.NewErrParamRequired("ModelId"))
2449	}
2450	if invalidParams.Len() > 0 {
2451		return invalidParams
2452	} else {
2453		return nil
2454	}
2455}
2456
2457func validateOpGetRouteInput(v *GetRouteInput) error {
2458	if v == nil {
2459		return nil
2460	}
2461	invalidParams := smithy.InvalidParamsError{Context: "GetRouteInput"}
2462	if v.ApiId == nil {
2463		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2464	}
2465	if v.RouteId == nil {
2466		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
2467	}
2468	if invalidParams.Len() > 0 {
2469		return invalidParams
2470	} else {
2471		return nil
2472	}
2473}
2474
2475func validateOpGetRouteResponseInput(v *GetRouteResponseInput) error {
2476	if v == nil {
2477		return nil
2478	}
2479	invalidParams := smithy.InvalidParamsError{Context: "GetRouteResponseInput"}
2480	if v.ApiId == nil {
2481		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2482	}
2483	if v.RouteId == nil {
2484		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
2485	}
2486	if v.RouteResponseId == nil {
2487		invalidParams.Add(smithy.NewErrParamRequired("RouteResponseId"))
2488	}
2489	if invalidParams.Len() > 0 {
2490		return invalidParams
2491	} else {
2492		return nil
2493	}
2494}
2495
2496func validateOpGetRouteResponsesInput(v *GetRouteResponsesInput) error {
2497	if v == nil {
2498		return nil
2499	}
2500	invalidParams := smithy.InvalidParamsError{Context: "GetRouteResponsesInput"}
2501	if v.ApiId == nil {
2502		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2503	}
2504	if v.RouteId == nil {
2505		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
2506	}
2507	if invalidParams.Len() > 0 {
2508		return invalidParams
2509	} else {
2510		return nil
2511	}
2512}
2513
2514func validateOpGetRoutesInput(v *GetRoutesInput) error {
2515	if v == nil {
2516		return nil
2517	}
2518	invalidParams := smithy.InvalidParamsError{Context: "GetRoutesInput"}
2519	if v.ApiId == nil {
2520		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2521	}
2522	if invalidParams.Len() > 0 {
2523		return invalidParams
2524	} else {
2525		return nil
2526	}
2527}
2528
2529func validateOpGetStageInput(v *GetStageInput) error {
2530	if v == nil {
2531		return nil
2532	}
2533	invalidParams := smithy.InvalidParamsError{Context: "GetStageInput"}
2534	if v.ApiId == nil {
2535		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2536	}
2537	if v.StageName == nil {
2538		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
2539	}
2540	if invalidParams.Len() > 0 {
2541		return invalidParams
2542	} else {
2543		return nil
2544	}
2545}
2546
2547func validateOpGetStagesInput(v *GetStagesInput) error {
2548	if v == nil {
2549		return nil
2550	}
2551	invalidParams := smithy.InvalidParamsError{Context: "GetStagesInput"}
2552	if v.ApiId == nil {
2553		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2554	}
2555	if invalidParams.Len() > 0 {
2556		return invalidParams
2557	} else {
2558		return nil
2559	}
2560}
2561
2562func validateOpGetTagsInput(v *GetTagsInput) error {
2563	if v == nil {
2564		return nil
2565	}
2566	invalidParams := smithy.InvalidParamsError{Context: "GetTagsInput"}
2567	if v.ResourceArn == nil {
2568		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2569	}
2570	if invalidParams.Len() > 0 {
2571		return invalidParams
2572	} else {
2573		return nil
2574	}
2575}
2576
2577func validateOpGetVpcLinkInput(v *GetVpcLinkInput) error {
2578	if v == nil {
2579		return nil
2580	}
2581	invalidParams := smithy.InvalidParamsError{Context: "GetVpcLinkInput"}
2582	if v.VpcLinkId == nil {
2583		invalidParams.Add(smithy.NewErrParamRequired("VpcLinkId"))
2584	}
2585	if invalidParams.Len() > 0 {
2586		return invalidParams
2587	} else {
2588		return nil
2589	}
2590}
2591
2592func validateOpImportApiInput(v *ImportApiInput) error {
2593	if v == nil {
2594		return nil
2595	}
2596	invalidParams := smithy.InvalidParamsError{Context: "ImportApiInput"}
2597	if v.Body == nil {
2598		invalidParams.Add(smithy.NewErrParamRequired("Body"))
2599	}
2600	if invalidParams.Len() > 0 {
2601		return invalidParams
2602	} else {
2603		return nil
2604	}
2605}
2606
2607func validateOpReimportApiInput(v *ReimportApiInput) error {
2608	if v == nil {
2609		return nil
2610	}
2611	invalidParams := smithy.InvalidParamsError{Context: "ReimportApiInput"}
2612	if v.ApiId == nil {
2613		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2614	}
2615	if v.Body == nil {
2616		invalidParams.Add(smithy.NewErrParamRequired("Body"))
2617	}
2618	if invalidParams.Len() > 0 {
2619		return invalidParams
2620	} else {
2621		return nil
2622	}
2623}
2624
2625func validateOpResetAuthorizersCacheInput(v *ResetAuthorizersCacheInput) error {
2626	if v == nil {
2627		return nil
2628	}
2629	invalidParams := smithy.InvalidParamsError{Context: "ResetAuthorizersCacheInput"}
2630	if v.ApiId == nil {
2631		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2632	}
2633	if v.StageName == nil {
2634		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
2635	}
2636	if invalidParams.Len() > 0 {
2637		return invalidParams
2638	} else {
2639		return nil
2640	}
2641}
2642
2643func validateOpTagResourceInput(v *TagResourceInput) error {
2644	if v == nil {
2645		return nil
2646	}
2647	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
2648	if v.ResourceArn == nil {
2649		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2650	}
2651	if invalidParams.Len() > 0 {
2652		return invalidParams
2653	} else {
2654		return nil
2655	}
2656}
2657
2658func validateOpUntagResourceInput(v *UntagResourceInput) error {
2659	if v == nil {
2660		return nil
2661	}
2662	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
2663	if v.ResourceArn == nil {
2664		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2665	}
2666	if v.TagKeys == nil {
2667		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
2668	}
2669	if invalidParams.Len() > 0 {
2670		return invalidParams
2671	} else {
2672		return nil
2673	}
2674}
2675
2676func validateOpUpdateApiInput(v *UpdateApiInput) error {
2677	if v == nil {
2678		return nil
2679	}
2680	invalidParams := smithy.InvalidParamsError{Context: "UpdateApiInput"}
2681	if v.ApiId == nil {
2682		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2683	}
2684	if invalidParams.Len() > 0 {
2685		return invalidParams
2686	} else {
2687		return nil
2688	}
2689}
2690
2691func validateOpUpdateApiMappingInput(v *UpdateApiMappingInput) error {
2692	if v == nil {
2693		return nil
2694	}
2695	invalidParams := smithy.InvalidParamsError{Context: "UpdateApiMappingInput"}
2696	if v.ApiId == nil {
2697		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2698	}
2699	if v.ApiMappingId == nil {
2700		invalidParams.Add(smithy.NewErrParamRequired("ApiMappingId"))
2701	}
2702	if v.DomainName == nil {
2703		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
2704	}
2705	if invalidParams.Len() > 0 {
2706		return invalidParams
2707	} else {
2708		return nil
2709	}
2710}
2711
2712func validateOpUpdateAuthorizerInput(v *UpdateAuthorizerInput) error {
2713	if v == nil {
2714		return nil
2715	}
2716	invalidParams := smithy.InvalidParamsError{Context: "UpdateAuthorizerInput"}
2717	if v.ApiId == nil {
2718		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2719	}
2720	if v.AuthorizerId == nil {
2721		invalidParams.Add(smithy.NewErrParamRequired("AuthorizerId"))
2722	}
2723	if invalidParams.Len() > 0 {
2724		return invalidParams
2725	} else {
2726		return nil
2727	}
2728}
2729
2730func validateOpUpdateDeploymentInput(v *UpdateDeploymentInput) error {
2731	if v == nil {
2732		return nil
2733	}
2734	invalidParams := smithy.InvalidParamsError{Context: "UpdateDeploymentInput"}
2735	if v.ApiId == nil {
2736		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2737	}
2738	if v.DeploymentId == nil {
2739		invalidParams.Add(smithy.NewErrParamRequired("DeploymentId"))
2740	}
2741	if invalidParams.Len() > 0 {
2742		return invalidParams
2743	} else {
2744		return nil
2745	}
2746}
2747
2748func validateOpUpdateDomainNameInput(v *UpdateDomainNameInput) error {
2749	if v == nil {
2750		return nil
2751	}
2752	invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainNameInput"}
2753	if v.DomainName == nil {
2754		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
2755	}
2756	if invalidParams.Len() > 0 {
2757		return invalidParams
2758	} else {
2759		return nil
2760	}
2761}
2762
2763func validateOpUpdateIntegrationInput(v *UpdateIntegrationInput) error {
2764	if v == nil {
2765		return nil
2766	}
2767	invalidParams := smithy.InvalidParamsError{Context: "UpdateIntegrationInput"}
2768	if v.ApiId == nil {
2769		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2770	}
2771	if v.IntegrationId == nil {
2772		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
2773	}
2774	if invalidParams.Len() > 0 {
2775		return invalidParams
2776	} else {
2777		return nil
2778	}
2779}
2780
2781func validateOpUpdateIntegrationResponseInput(v *UpdateIntegrationResponseInput) error {
2782	if v == nil {
2783		return nil
2784	}
2785	invalidParams := smithy.InvalidParamsError{Context: "UpdateIntegrationResponseInput"}
2786	if v.ApiId == nil {
2787		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2788	}
2789	if v.IntegrationId == nil {
2790		invalidParams.Add(smithy.NewErrParamRequired("IntegrationId"))
2791	}
2792	if v.IntegrationResponseId == nil {
2793		invalidParams.Add(smithy.NewErrParamRequired("IntegrationResponseId"))
2794	}
2795	if invalidParams.Len() > 0 {
2796		return invalidParams
2797	} else {
2798		return nil
2799	}
2800}
2801
2802func validateOpUpdateModelInput(v *UpdateModelInput) error {
2803	if v == nil {
2804		return nil
2805	}
2806	invalidParams := smithy.InvalidParamsError{Context: "UpdateModelInput"}
2807	if v.ApiId == nil {
2808		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2809	}
2810	if v.ModelId == nil {
2811		invalidParams.Add(smithy.NewErrParamRequired("ModelId"))
2812	}
2813	if invalidParams.Len() > 0 {
2814		return invalidParams
2815	} else {
2816		return nil
2817	}
2818}
2819
2820func validateOpUpdateRouteInput(v *UpdateRouteInput) error {
2821	if v == nil {
2822		return nil
2823	}
2824	invalidParams := smithy.InvalidParamsError{Context: "UpdateRouteInput"}
2825	if v.ApiId == nil {
2826		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2827	}
2828	if v.RouteId == nil {
2829		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
2830	}
2831	if invalidParams.Len() > 0 {
2832		return invalidParams
2833	} else {
2834		return nil
2835	}
2836}
2837
2838func validateOpUpdateRouteResponseInput(v *UpdateRouteResponseInput) error {
2839	if v == nil {
2840		return nil
2841	}
2842	invalidParams := smithy.InvalidParamsError{Context: "UpdateRouteResponseInput"}
2843	if v.ApiId == nil {
2844		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2845	}
2846	if v.RouteId == nil {
2847		invalidParams.Add(smithy.NewErrParamRequired("RouteId"))
2848	}
2849	if v.RouteResponseId == nil {
2850		invalidParams.Add(smithy.NewErrParamRequired("RouteResponseId"))
2851	}
2852	if invalidParams.Len() > 0 {
2853		return invalidParams
2854	} else {
2855		return nil
2856	}
2857}
2858
2859func validateOpUpdateStageInput(v *UpdateStageInput) error {
2860	if v == nil {
2861		return nil
2862	}
2863	invalidParams := smithy.InvalidParamsError{Context: "UpdateStageInput"}
2864	if v.ApiId == nil {
2865		invalidParams.Add(smithy.NewErrParamRequired("ApiId"))
2866	}
2867	if v.StageName == nil {
2868		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
2869	}
2870	if invalidParams.Len() > 0 {
2871		return invalidParams
2872	} else {
2873		return nil
2874	}
2875}
2876
2877func validateOpUpdateVpcLinkInput(v *UpdateVpcLinkInput) error {
2878	if v == nil {
2879		return nil
2880	}
2881	invalidParams := smithy.InvalidParamsError{Context: "UpdateVpcLinkInput"}
2882	if v.VpcLinkId == nil {
2883		invalidParams.Add(smithy.NewErrParamRequired("VpcLinkId"))
2884	}
2885	if invalidParams.Len() > 0 {
2886		return invalidParams
2887	} else {
2888		return nil
2889	}
2890}
2891