1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package apigateway
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/apigateway/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCreateAuthorizer struct {
14}
15
16func (*validateOpCreateAuthorizer) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCreateAuthorizer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
21	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
22) {
23	input, ok := in.Parameters.(*CreateAuthorizerInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCreateAuthorizerInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateBasePathMapping struct {
34}
35
36func (*validateOpCreateBasePathMapping) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateBasePathMapping) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
41	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
42) {
43	input, ok := in.Parameters.(*CreateBasePathMappingInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateBasePathMappingInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateDeployment struct {
54}
55
56func (*validateOpCreateDeployment) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
61	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
62) {
63	input, ok := in.Parameters.(*CreateDeploymentInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateDeploymentInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateDocumentationPart struct {
74}
75
76func (*validateOpCreateDocumentationPart) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateDocumentationPart) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
81	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
82) {
83	input, ok := in.Parameters.(*CreateDocumentationPartInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateDocumentationPartInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateDocumentationVersion struct {
94}
95
96func (*validateOpCreateDocumentationVersion) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateDocumentationVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
102) {
103	input, ok := in.Parameters.(*CreateDocumentationVersionInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateDocumentationVersionInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateDomainName struct {
114}
115
116func (*validateOpCreateDomainName) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateDomainName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
122) {
123	input, ok := in.Parameters.(*CreateDomainNameInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateDomainNameInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpCreateModel struct {
134}
135
136func (*validateOpCreateModel) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpCreateModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
142) {
143	input, ok := in.Parameters.(*CreateModelInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpCreateModelInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpCreateRequestValidator struct {
154}
155
156func (*validateOpCreateRequestValidator) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpCreateRequestValidator) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
161	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
162) {
163	input, ok := in.Parameters.(*CreateRequestValidatorInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpCreateRequestValidatorInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpCreateResource struct {
174}
175
176func (*validateOpCreateResource) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpCreateResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
181	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
182) {
183	input, ok := in.Parameters.(*CreateResourceInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpCreateResourceInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpCreateRestApi struct {
194}
195
196func (*validateOpCreateRestApi) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpCreateRestApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
201	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
202) {
203	input, ok := in.Parameters.(*CreateRestApiInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpCreateRestApiInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpCreateStage struct {
214}
215
216func (*validateOpCreateStage) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpCreateStage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
221	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
222) {
223	input, ok := in.Parameters.(*CreateStageInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpCreateStageInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpCreateUsagePlan struct {
234}
235
236func (*validateOpCreateUsagePlan) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpCreateUsagePlan) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
241	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
242) {
243	input, ok := in.Parameters.(*CreateUsagePlanInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpCreateUsagePlanInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpCreateUsagePlanKey struct {
254}
255
256func (*validateOpCreateUsagePlanKey) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpCreateUsagePlanKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
261	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
262) {
263	input, ok := in.Parameters.(*CreateUsagePlanKeyInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpCreateUsagePlanKeyInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpCreateVpcLink struct {
274}
275
276func (*validateOpCreateVpcLink) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpCreateVpcLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
281	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
282) {
283	input, ok := in.Parameters.(*CreateVpcLinkInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpCreateVpcLinkInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDeleteApiKey struct {
294}
295
296func (*validateOpDeleteApiKey) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDeleteApiKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
301	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
302) {
303	input, ok := in.Parameters.(*DeleteApiKeyInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDeleteApiKeyInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDeleteAuthorizer struct {
314}
315
316func (*validateOpDeleteAuthorizer) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDeleteAuthorizer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
321	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
322) {
323	input, ok := in.Parameters.(*DeleteAuthorizerInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDeleteAuthorizerInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDeleteBasePathMapping struct {
334}
335
336func (*validateOpDeleteBasePathMapping) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDeleteBasePathMapping) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
341	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
342) {
343	input, ok := in.Parameters.(*DeleteBasePathMappingInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDeleteBasePathMappingInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDeleteClientCertificate struct {
354}
355
356func (*validateOpDeleteClientCertificate) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDeleteClientCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
361	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
362) {
363	input, ok := in.Parameters.(*DeleteClientCertificateInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDeleteClientCertificateInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDeleteDeployment struct {
374}
375
376func (*validateOpDeleteDeployment) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDeleteDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
381	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
382) {
383	input, ok := in.Parameters.(*DeleteDeploymentInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDeleteDeploymentInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDeleteDocumentationPart struct {
394}
395
396func (*validateOpDeleteDocumentationPart) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDeleteDocumentationPart) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
401	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
402) {
403	input, ok := in.Parameters.(*DeleteDocumentationPartInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDeleteDocumentationPartInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDeleteDocumentationVersion struct {
414}
415
416func (*validateOpDeleteDocumentationVersion) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDeleteDocumentationVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
421	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
422) {
423	input, ok := in.Parameters.(*DeleteDocumentationVersionInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDeleteDocumentationVersionInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpDeleteDomainName struct {
434}
435
436func (*validateOpDeleteDomainName) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpDeleteDomainName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
441	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
442) {
443	input, ok := in.Parameters.(*DeleteDomainNameInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpDeleteDomainNameInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpDeleteGatewayResponse struct {
454}
455
456func (*validateOpDeleteGatewayResponse) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpDeleteGatewayResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
461	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
462) {
463	input, ok := in.Parameters.(*DeleteGatewayResponseInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpDeleteGatewayResponseInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpDeleteIntegration struct {
474}
475
476func (*validateOpDeleteIntegration) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpDeleteIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
481	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
482) {
483	input, ok := in.Parameters.(*DeleteIntegrationInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpDeleteIntegrationInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpDeleteIntegrationResponse struct {
494}
495
496func (*validateOpDeleteIntegrationResponse) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpDeleteIntegrationResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
501	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
502) {
503	input, ok := in.Parameters.(*DeleteIntegrationResponseInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpDeleteIntegrationResponseInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpDeleteMethod struct {
514}
515
516func (*validateOpDeleteMethod) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpDeleteMethod) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
521	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
522) {
523	input, ok := in.Parameters.(*DeleteMethodInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpDeleteMethodInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpDeleteMethodResponse struct {
534}
535
536func (*validateOpDeleteMethodResponse) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpDeleteMethodResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
541	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
542) {
543	input, ok := in.Parameters.(*DeleteMethodResponseInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpDeleteMethodResponseInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpDeleteModel struct {
554}
555
556func (*validateOpDeleteModel) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpDeleteModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
561	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
562) {
563	input, ok := in.Parameters.(*DeleteModelInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpDeleteModelInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpDeleteRequestValidator struct {
574}
575
576func (*validateOpDeleteRequestValidator) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpDeleteRequestValidator) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
581	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
582) {
583	input, ok := in.Parameters.(*DeleteRequestValidatorInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpDeleteRequestValidatorInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpDeleteResource struct {
594}
595
596func (*validateOpDeleteResource) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpDeleteResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
601	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
602) {
603	input, ok := in.Parameters.(*DeleteResourceInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpDeleteResourceInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpDeleteRestApi struct {
614}
615
616func (*validateOpDeleteRestApi) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpDeleteRestApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
621	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
622) {
623	input, ok := in.Parameters.(*DeleteRestApiInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpDeleteRestApiInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpDeleteStage struct {
634}
635
636func (*validateOpDeleteStage) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpDeleteStage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
641	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
642) {
643	input, ok := in.Parameters.(*DeleteStageInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpDeleteStageInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpDeleteUsagePlan struct {
654}
655
656func (*validateOpDeleteUsagePlan) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpDeleteUsagePlan) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
661	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
662) {
663	input, ok := in.Parameters.(*DeleteUsagePlanInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpDeleteUsagePlanInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpDeleteUsagePlanKey struct {
674}
675
676func (*validateOpDeleteUsagePlanKey) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpDeleteUsagePlanKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
681	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
682) {
683	input, ok := in.Parameters.(*DeleteUsagePlanKeyInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpDeleteUsagePlanKeyInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpDeleteVpcLink struct {
694}
695
696func (*validateOpDeleteVpcLink) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpDeleteVpcLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
701	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
702) {
703	input, ok := in.Parameters.(*DeleteVpcLinkInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpDeleteVpcLinkInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpFlushStageAuthorizersCache struct {
714}
715
716func (*validateOpFlushStageAuthorizersCache) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpFlushStageAuthorizersCache) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
721	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
722) {
723	input, ok := in.Parameters.(*FlushStageAuthorizersCacheInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpFlushStageAuthorizersCacheInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpFlushStageCache struct {
734}
735
736func (*validateOpFlushStageCache) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpFlushStageCache) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
741	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
742) {
743	input, ok := in.Parameters.(*FlushStageCacheInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpFlushStageCacheInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpGetApiKey struct {
754}
755
756func (*validateOpGetApiKey) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpGetApiKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
761	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
762) {
763	input, ok := in.Parameters.(*GetApiKeyInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpGetApiKeyInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpGetAuthorizer struct {
774}
775
776func (*validateOpGetAuthorizer) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpGetAuthorizer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
781	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
782) {
783	input, ok := in.Parameters.(*GetAuthorizerInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpGetAuthorizerInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpGetAuthorizers struct {
794}
795
796func (*validateOpGetAuthorizers) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpGetAuthorizers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
801	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
802) {
803	input, ok := in.Parameters.(*GetAuthorizersInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpGetAuthorizersInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpGetBasePathMapping struct {
814}
815
816func (*validateOpGetBasePathMapping) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpGetBasePathMapping) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
821	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
822) {
823	input, ok := in.Parameters.(*GetBasePathMappingInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpGetBasePathMappingInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpGetBasePathMappings struct {
834}
835
836func (*validateOpGetBasePathMappings) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpGetBasePathMappings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
841	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
842) {
843	input, ok := in.Parameters.(*GetBasePathMappingsInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpGetBasePathMappingsInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpGetClientCertificate struct {
854}
855
856func (*validateOpGetClientCertificate) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpGetClientCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
861	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
862) {
863	input, ok := in.Parameters.(*GetClientCertificateInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpGetClientCertificateInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpGetDeployment struct {
874}
875
876func (*validateOpGetDeployment) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpGetDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
881	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
882) {
883	input, ok := in.Parameters.(*GetDeploymentInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpGetDeploymentInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893type validateOpGetDeployments struct {
894}
895
896func (*validateOpGetDeployments) ID() string {
897	return "OperationInputValidation"
898}
899
900func (m *validateOpGetDeployments) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
901	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
902) {
903	input, ok := in.Parameters.(*GetDeploymentsInput)
904	if !ok {
905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
906	}
907	if err := validateOpGetDeploymentsInput(input); err != nil {
908		return out, metadata, err
909	}
910	return next.HandleInitialize(ctx, in)
911}
912
913type validateOpGetDocumentationPart struct {
914}
915
916func (*validateOpGetDocumentationPart) ID() string {
917	return "OperationInputValidation"
918}
919
920func (m *validateOpGetDocumentationPart) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
921	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
922) {
923	input, ok := in.Parameters.(*GetDocumentationPartInput)
924	if !ok {
925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
926	}
927	if err := validateOpGetDocumentationPartInput(input); err != nil {
928		return out, metadata, err
929	}
930	return next.HandleInitialize(ctx, in)
931}
932
933type validateOpGetDocumentationParts struct {
934}
935
936func (*validateOpGetDocumentationParts) ID() string {
937	return "OperationInputValidation"
938}
939
940func (m *validateOpGetDocumentationParts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
941	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
942) {
943	input, ok := in.Parameters.(*GetDocumentationPartsInput)
944	if !ok {
945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
946	}
947	if err := validateOpGetDocumentationPartsInput(input); err != nil {
948		return out, metadata, err
949	}
950	return next.HandleInitialize(ctx, in)
951}
952
953type validateOpGetDocumentationVersion struct {
954}
955
956func (*validateOpGetDocumentationVersion) ID() string {
957	return "OperationInputValidation"
958}
959
960func (m *validateOpGetDocumentationVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
961	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
962) {
963	input, ok := in.Parameters.(*GetDocumentationVersionInput)
964	if !ok {
965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
966	}
967	if err := validateOpGetDocumentationVersionInput(input); err != nil {
968		return out, metadata, err
969	}
970	return next.HandleInitialize(ctx, in)
971}
972
973type validateOpGetDocumentationVersions struct {
974}
975
976func (*validateOpGetDocumentationVersions) ID() string {
977	return "OperationInputValidation"
978}
979
980func (m *validateOpGetDocumentationVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
981	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
982) {
983	input, ok := in.Parameters.(*GetDocumentationVersionsInput)
984	if !ok {
985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
986	}
987	if err := validateOpGetDocumentationVersionsInput(input); err != nil {
988		return out, metadata, err
989	}
990	return next.HandleInitialize(ctx, in)
991}
992
993type validateOpGetDomainName struct {
994}
995
996func (*validateOpGetDomainName) ID() string {
997	return "OperationInputValidation"
998}
999
1000func (m *validateOpGetDomainName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1001	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1002) {
1003	input, ok := in.Parameters.(*GetDomainNameInput)
1004	if !ok {
1005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1006	}
1007	if err := validateOpGetDomainNameInput(input); err != nil {
1008		return out, metadata, err
1009	}
1010	return next.HandleInitialize(ctx, in)
1011}
1012
1013type validateOpGetExport struct {
1014}
1015
1016func (*validateOpGetExport) ID() string {
1017	return "OperationInputValidation"
1018}
1019
1020func (m *validateOpGetExport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1021	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1022) {
1023	input, ok := in.Parameters.(*GetExportInput)
1024	if !ok {
1025		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1026	}
1027	if err := validateOpGetExportInput(input); err != nil {
1028		return out, metadata, err
1029	}
1030	return next.HandleInitialize(ctx, in)
1031}
1032
1033type validateOpGetGatewayResponse struct {
1034}
1035
1036func (*validateOpGetGatewayResponse) ID() string {
1037	return "OperationInputValidation"
1038}
1039
1040func (m *validateOpGetGatewayResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1041	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1042) {
1043	input, ok := in.Parameters.(*GetGatewayResponseInput)
1044	if !ok {
1045		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1046	}
1047	if err := validateOpGetGatewayResponseInput(input); err != nil {
1048		return out, metadata, err
1049	}
1050	return next.HandleInitialize(ctx, in)
1051}
1052
1053type validateOpGetGatewayResponses struct {
1054}
1055
1056func (*validateOpGetGatewayResponses) ID() string {
1057	return "OperationInputValidation"
1058}
1059
1060func (m *validateOpGetGatewayResponses) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1061	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1062) {
1063	input, ok := in.Parameters.(*GetGatewayResponsesInput)
1064	if !ok {
1065		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1066	}
1067	if err := validateOpGetGatewayResponsesInput(input); err != nil {
1068		return out, metadata, err
1069	}
1070	return next.HandleInitialize(ctx, in)
1071}
1072
1073type validateOpGetIntegration struct {
1074}
1075
1076func (*validateOpGetIntegration) ID() string {
1077	return "OperationInputValidation"
1078}
1079
1080func (m *validateOpGetIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1081	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1082) {
1083	input, ok := in.Parameters.(*GetIntegrationInput)
1084	if !ok {
1085		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1086	}
1087	if err := validateOpGetIntegrationInput(input); err != nil {
1088		return out, metadata, err
1089	}
1090	return next.HandleInitialize(ctx, in)
1091}
1092
1093type validateOpGetIntegrationResponse struct {
1094}
1095
1096func (*validateOpGetIntegrationResponse) ID() string {
1097	return "OperationInputValidation"
1098}
1099
1100func (m *validateOpGetIntegrationResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1102) {
1103	input, ok := in.Parameters.(*GetIntegrationResponseInput)
1104	if !ok {
1105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1106	}
1107	if err := validateOpGetIntegrationResponseInput(input); err != nil {
1108		return out, metadata, err
1109	}
1110	return next.HandleInitialize(ctx, in)
1111}
1112
1113type validateOpGetMethod struct {
1114}
1115
1116func (*validateOpGetMethod) ID() string {
1117	return "OperationInputValidation"
1118}
1119
1120func (m *validateOpGetMethod) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1122) {
1123	input, ok := in.Parameters.(*GetMethodInput)
1124	if !ok {
1125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1126	}
1127	if err := validateOpGetMethodInput(input); err != nil {
1128		return out, metadata, err
1129	}
1130	return next.HandleInitialize(ctx, in)
1131}
1132
1133type validateOpGetMethodResponse struct {
1134}
1135
1136func (*validateOpGetMethodResponse) ID() string {
1137	return "OperationInputValidation"
1138}
1139
1140func (m *validateOpGetMethodResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1142) {
1143	input, ok := in.Parameters.(*GetMethodResponseInput)
1144	if !ok {
1145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1146	}
1147	if err := validateOpGetMethodResponseInput(input); err != nil {
1148		return out, metadata, err
1149	}
1150	return next.HandleInitialize(ctx, in)
1151}
1152
1153type validateOpGetModel struct {
1154}
1155
1156func (*validateOpGetModel) ID() string {
1157	return "OperationInputValidation"
1158}
1159
1160func (m *validateOpGetModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1161	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1162) {
1163	input, ok := in.Parameters.(*GetModelInput)
1164	if !ok {
1165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1166	}
1167	if err := validateOpGetModelInput(input); err != nil {
1168		return out, metadata, err
1169	}
1170	return next.HandleInitialize(ctx, in)
1171}
1172
1173type validateOpGetModels struct {
1174}
1175
1176func (*validateOpGetModels) ID() string {
1177	return "OperationInputValidation"
1178}
1179
1180func (m *validateOpGetModels) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1181	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1182) {
1183	input, ok := in.Parameters.(*GetModelsInput)
1184	if !ok {
1185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1186	}
1187	if err := validateOpGetModelsInput(input); err != nil {
1188		return out, metadata, err
1189	}
1190	return next.HandleInitialize(ctx, in)
1191}
1192
1193type validateOpGetModelTemplate struct {
1194}
1195
1196func (*validateOpGetModelTemplate) ID() string {
1197	return "OperationInputValidation"
1198}
1199
1200func (m *validateOpGetModelTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1201	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1202) {
1203	input, ok := in.Parameters.(*GetModelTemplateInput)
1204	if !ok {
1205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1206	}
1207	if err := validateOpGetModelTemplateInput(input); err != nil {
1208		return out, metadata, err
1209	}
1210	return next.HandleInitialize(ctx, in)
1211}
1212
1213type validateOpGetRequestValidator struct {
1214}
1215
1216func (*validateOpGetRequestValidator) ID() string {
1217	return "OperationInputValidation"
1218}
1219
1220func (m *validateOpGetRequestValidator) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1221	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1222) {
1223	input, ok := in.Parameters.(*GetRequestValidatorInput)
1224	if !ok {
1225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1226	}
1227	if err := validateOpGetRequestValidatorInput(input); err != nil {
1228		return out, metadata, err
1229	}
1230	return next.HandleInitialize(ctx, in)
1231}
1232
1233type validateOpGetRequestValidators struct {
1234}
1235
1236func (*validateOpGetRequestValidators) ID() string {
1237	return "OperationInputValidation"
1238}
1239
1240func (m *validateOpGetRequestValidators) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1241	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1242) {
1243	input, ok := in.Parameters.(*GetRequestValidatorsInput)
1244	if !ok {
1245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1246	}
1247	if err := validateOpGetRequestValidatorsInput(input); err != nil {
1248		return out, metadata, err
1249	}
1250	return next.HandleInitialize(ctx, in)
1251}
1252
1253type validateOpGetResource struct {
1254}
1255
1256func (*validateOpGetResource) ID() string {
1257	return "OperationInputValidation"
1258}
1259
1260func (m *validateOpGetResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1261	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1262) {
1263	input, ok := in.Parameters.(*GetResourceInput)
1264	if !ok {
1265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1266	}
1267	if err := validateOpGetResourceInput(input); err != nil {
1268		return out, metadata, err
1269	}
1270	return next.HandleInitialize(ctx, in)
1271}
1272
1273type validateOpGetResources struct {
1274}
1275
1276func (*validateOpGetResources) ID() string {
1277	return "OperationInputValidation"
1278}
1279
1280func (m *validateOpGetResources) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1281	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1282) {
1283	input, ok := in.Parameters.(*GetResourcesInput)
1284	if !ok {
1285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1286	}
1287	if err := validateOpGetResourcesInput(input); err != nil {
1288		return out, metadata, err
1289	}
1290	return next.HandleInitialize(ctx, in)
1291}
1292
1293type validateOpGetRestApi struct {
1294}
1295
1296func (*validateOpGetRestApi) ID() string {
1297	return "OperationInputValidation"
1298}
1299
1300func (m *validateOpGetRestApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1301	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1302) {
1303	input, ok := in.Parameters.(*GetRestApiInput)
1304	if !ok {
1305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1306	}
1307	if err := validateOpGetRestApiInput(input); err != nil {
1308		return out, metadata, err
1309	}
1310	return next.HandleInitialize(ctx, in)
1311}
1312
1313type validateOpGetSdk struct {
1314}
1315
1316func (*validateOpGetSdk) ID() string {
1317	return "OperationInputValidation"
1318}
1319
1320func (m *validateOpGetSdk) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1321	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1322) {
1323	input, ok := in.Parameters.(*GetSdkInput)
1324	if !ok {
1325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1326	}
1327	if err := validateOpGetSdkInput(input); err != nil {
1328		return out, metadata, err
1329	}
1330	return next.HandleInitialize(ctx, in)
1331}
1332
1333type validateOpGetSdkType struct {
1334}
1335
1336func (*validateOpGetSdkType) ID() string {
1337	return "OperationInputValidation"
1338}
1339
1340func (m *validateOpGetSdkType) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1341	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1342) {
1343	input, ok := in.Parameters.(*GetSdkTypeInput)
1344	if !ok {
1345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1346	}
1347	if err := validateOpGetSdkTypeInput(input); err != nil {
1348		return out, metadata, err
1349	}
1350	return next.HandleInitialize(ctx, in)
1351}
1352
1353type validateOpGetStage struct {
1354}
1355
1356func (*validateOpGetStage) ID() string {
1357	return "OperationInputValidation"
1358}
1359
1360func (m *validateOpGetStage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1361	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1362) {
1363	input, ok := in.Parameters.(*GetStageInput)
1364	if !ok {
1365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1366	}
1367	if err := validateOpGetStageInput(input); err != nil {
1368		return out, metadata, err
1369	}
1370	return next.HandleInitialize(ctx, in)
1371}
1372
1373type validateOpGetStages struct {
1374}
1375
1376func (*validateOpGetStages) ID() string {
1377	return "OperationInputValidation"
1378}
1379
1380func (m *validateOpGetStages) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1381	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1382) {
1383	input, ok := in.Parameters.(*GetStagesInput)
1384	if !ok {
1385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1386	}
1387	if err := validateOpGetStagesInput(input); err != nil {
1388		return out, metadata, err
1389	}
1390	return next.HandleInitialize(ctx, in)
1391}
1392
1393type validateOpGetTags struct {
1394}
1395
1396func (*validateOpGetTags) ID() string {
1397	return "OperationInputValidation"
1398}
1399
1400func (m *validateOpGetTags) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1401	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1402) {
1403	input, ok := in.Parameters.(*GetTagsInput)
1404	if !ok {
1405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1406	}
1407	if err := validateOpGetTagsInput(input); err != nil {
1408		return out, metadata, err
1409	}
1410	return next.HandleInitialize(ctx, in)
1411}
1412
1413type validateOpGetUsage struct {
1414}
1415
1416func (*validateOpGetUsage) ID() string {
1417	return "OperationInputValidation"
1418}
1419
1420func (m *validateOpGetUsage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1421	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1422) {
1423	input, ok := in.Parameters.(*GetUsageInput)
1424	if !ok {
1425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1426	}
1427	if err := validateOpGetUsageInput(input); err != nil {
1428		return out, metadata, err
1429	}
1430	return next.HandleInitialize(ctx, in)
1431}
1432
1433type validateOpGetUsagePlan struct {
1434}
1435
1436func (*validateOpGetUsagePlan) ID() string {
1437	return "OperationInputValidation"
1438}
1439
1440func (m *validateOpGetUsagePlan) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1441	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1442) {
1443	input, ok := in.Parameters.(*GetUsagePlanInput)
1444	if !ok {
1445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1446	}
1447	if err := validateOpGetUsagePlanInput(input); err != nil {
1448		return out, metadata, err
1449	}
1450	return next.HandleInitialize(ctx, in)
1451}
1452
1453type validateOpGetUsagePlanKey struct {
1454}
1455
1456func (*validateOpGetUsagePlanKey) ID() string {
1457	return "OperationInputValidation"
1458}
1459
1460func (m *validateOpGetUsagePlanKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1461	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1462) {
1463	input, ok := in.Parameters.(*GetUsagePlanKeyInput)
1464	if !ok {
1465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1466	}
1467	if err := validateOpGetUsagePlanKeyInput(input); err != nil {
1468		return out, metadata, err
1469	}
1470	return next.HandleInitialize(ctx, in)
1471}
1472
1473type validateOpGetUsagePlanKeys struct {
1474}
1475
1476func (*validateOpGetUsagePlanKeys) ID() string {
1477	return "OperationInputValidation"
1478}
1479
1480func (m *validateOpGetUsagePlanKeys) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1481	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1482) {
1483	input, ok := in.Parameters.(*GetUsagePlanKeysInput)
1484	if !ok {
1485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1486	}
1487	if err := validateOpGetUsagePlanKeysInput(input); err != nil {
1488		return out, metadata, err
1489	}
1490	return next.HandleInitialize(ctx, in)
1491}
1492
1493type validateOpGetVpcLink struct {
1494}
1495
1496func (*validateOpGetVpcLink) ID() string {
1497	return "OperationInputValidation"
1498}
1499
1500func (m *validateOpGetVpcLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1501	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1502) {
1503	input, ok := in.Parameters.(*GetVpcLinkInput)
1504	if !ok {
1505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1506	}
1507	if err := validateOpGetVpcLinkInput(input); err != nil {
1508		return out, metadata, err
1509	}
1510	return next.HandleInitialize(ctx, in)
1511}
1512
1513type validateOpImportApiKeys struct {
1514}
1515
1516func (*validateOpImportApiKeys) ID() string {
1517	return "OperationInputValidation"
1518}
1519
1520func (m *validateOpImportApiKeys) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1521	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1522) {
1523	input, ok := in.Parameters.(*ImportApiKeysInput)
1524	if !ok {
1525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1526	}
1527	if err := validateOpImportApiKeysInput(input); err != nil {
1528		return out, metadata, err
1529	}
1530	return next.HandleInitialize(ctx, in)
1531}
1532
1533type validateOpImportDocumentationParts struct {
1534}
1535
1536func (*validateOpImportDocumentationParts) ID() string {
1537	return "OperationInputValidation"
1538}
1539
1540func (m *validateOpImportDocumentationParts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1541	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1542) {
1543	input, ok := in.Parameters.(*ImportDocumentationPartsInput)
1544	if !ok {
1545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1546	}
1547	if err := validateOpImportDocumentationPartsInput(input); err != nil {
1548		return out, metadata, err
1549	}
1550	return next.HandleInitialize(ctx, in)
1551}
1552
1553type validateOpImportRestApi struct {
1554}
1555
1556func (*validateOpImportRestApi) ID() string {
1557	return "OperationInputValidation"
1558}
1559
1560func (m *validateOpImportRestApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1561	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1562) {
1563	input, ok := in.Parameters.(*ImportRestApiInput)
1564	if !ok {
1565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1566	}
1567	if err := validateOpImportRestApiInput(input); err != nil {
1568		return out, metadata, err
1569	}
1570	return next.HandleInitialize(ctx, in)
1571}
1572
1573type validateOpPutGatewayResponse struct {
1574}
1575
1576func (*validateOpPutGatewayResponse) ID() string {
1577	return "OperationInputValidation"
1578}
1579
1580func (m *validateOpPutGatewayResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1581	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1582) {
1583	input, ok := in.Parameters.(*PutGatewayResponseInput)
1584	if !ok {
1585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1586	}
1587	if err := validateOpPutGatewayResponseInput(input); err != nil {
1588		return out, metadata, err
1589	}
1590	return next.HandleInitialize(ctx, in)
1591}
1592
1593type validateOpPutIntegration struct {
1594}
1595
1596func (*validateOpPutIntegration) ID() string {
1597	return "OperationInputValidation"
1598}
1599
1600func (m *validateOpPutIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1601	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1602) {
1603	input, ok := in.Parameters.(*PutIntegrationInput)
1604	if !ok {
1605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1606	}
1607	if err := validateOpPutIntegrationInput(input); err != nil {
1608		return out, metadata, err
1609	}
1610	return next.HandleInitialize(ctx, in)
1611}
1612
1613type validateOpPutIntegrationResponse struct {
1614}
1615
1616func (*validateOpPutIntegrationResponse) ID() string {
1617	return "OperationInputValidation"
1618}
1619
1620func (m *validateOpPutIntegrationResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1621	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1622) {
1623	input, ok := in.Parameters.(*PutIntegrationResponseInput)
1624	if !ok {
1625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1626	}
1627	if err := validateOpPutIntegrationResponseInput(input); err != nil {
1628		return out, metadata, err
1629	}
1630	return next.HandleInitialize(ctx, in)
1631}
1632
1633type validateOpPutMethod struct {
1634}
1635
1636func (*validateOpPutMethod) ID() string {
1637	return "OperationInputValidation"
1638}
1639
1640func (m *validateOpPutMethod) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1641	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1642) {
1643	input, ok := in.Parameters.(*PutMethodInput)
1644	if !ok {
1645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1646	}
1647	if err := validateOpPutMethodInput(input); err != nil {
1648		return out, metadata, err
1649	}
1650	return next.HandleInitialize(ctx, in)
1651}
1652
1653type validateOpPutMethodResponse struct {
1654}
1655
1656func (*validateOpPutMethodResponse) ID() string {
1657	return "OperationInputValidation"
1658}
1659
1660func (m *validateOpPutMethodResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1661	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1662) {
1663	input, ok := in.Parameters.(*PutMethodResponseInput)
1664	if !ok {
1665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1666	}
1667	if err := validateOpPutMethodResponseInput(input); err != nil {
1668		return out, metadata, err
1669	}
1670	return next.HandleInitialize(ctx, in)
1671}
1672
1673type validateOpPutRestApi struct {
1674}
1675
1676func (*validateOpPutRestApi) ID() string {
1677	return "OperationInputValidation"
1678}
1679
1680func (m *validateOpPutRestApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1681	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1682) {
1683	input, ok := in.Parameters.(*PutRestApiInput)
1684	if !ok {
1685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1686	}
1687	if err := validateOpPutRestApiInput(input); err != nil {
1688		return out, metadata, err
1689	}
1690	return next.HandleInitialize(ctx, in)
1691}
1692
1693type validateOpTagResource struct {
1694}
1695
1696func (*validateOpTagResource) ID() string {
1697	return "OperationInputValidation"
1698}
1699
1700func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1701	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1702) {
1703	input, ok := in.Parameters.(*TagResourceInput)
1704	if !ok {
1705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1706	}
1707	if err := validateOpTagResourceInput(input); err != nil {
1708		return out, metadata, err
1709	}
1710	return next.HandleInitialize(ctx, in)
1711}
1712
1713type validateOpTestInvokeAuthorizer struct {
1714}
1715
1716func (*validateOpTestInvokeAuthorizer) ID() string {
1717	return "OperationInputValidation"
1718}
1719
1720func (m *validateOpTestInvokeAuthorizer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1721	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1722) {
1723	input, ok := in.Parameters.(*TestInvokeAuthorizerInput)
1724	if !ok {
1725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1726	}
1727	if err := validateOpTestInvokeAuthorizerInput(input); err != nil {
1728		return out, metadata, err
1729	}
1730	return next.HandleInitialize(ctx, in)
1731}
1732
1733type validateOpTestInvokeMethod struct {
1734}
1735
1736func (*validateOpTestInvokeMethod) ID() string {
1737	return "OperationInputValidation"
1738}
1739
1740func (m *validateOpTestInvokeMethod) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1741	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1742) {
1743	input, ok := in.Parameters.(*TestInvokeMethodInput)
1744	if !ok {
1745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1746	}
1747	if err := validateOpTestInvokeMethodInput(input); err != nil {
1748		return out, metadata, err
1749	}
1750	return next.HandleInitialize(ctx, in)
1751}
1752
1753type validateOpUntagResource struct {
1754}
1755
1756func (*validateOpUntagResource) ID() string {
1757	return "OperationInputValidation"
1758}
1759
1760func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1761	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1762) {
1763	input, ok := in.Parameters.(*UntagResourceInput)
1764	if !ok {
1765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1766	}
1767	if err := validateOpUntagResourceInput(input); err != nil {
1768		return out, metadata, err
1769	}
1770	return next.HandleInitialize(ctx, in)
1771}
1772
1773type validateOpUpdateApiKey struct {
1774}
1775
1776func (*validateOpUpdateApiKey) ID() string {
1777	return "OperationInputValidation"
1778}
1779
1780func (m *validateOpUpdateApiKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1781	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1782) {
1783	input, ok := in.Parameters.(*UpdateApiKeyInput)
1784	if !ok {
1785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1786	}
1787	if err := validateOpUpdateApiKeyInput(input); err != nil {
1788		return out, metadata, err
1789	}
1790	return next.HandleInitialize(ctx, in)
1791}
1792
1793type validateOpUpdateAuthorizer struct {
1794}
1795
1796func (*validateOpUpdateAuthorizer) ID() string {
1797	return "OperationInputValidation"
1798}
1799
1800func (m *validateOpUpdateAuthorizer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1801	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1802) {
1803	input, ok := in.Parameters.(*UpdateAuthorizerInput)
1804	if !ok {
1805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1806	}
1807	if err := validateOpUpdateAuthorizerInput(input); err != nil {
1808		return out, metadata, err
1809	}
1810	return next.HandleInitialize(ctx, in)
1811}
1812
1813type validateOpUpdateBasePathMapping struct {
1814}
1815
1816func (*validateOpUpdateBasePathMapping) ID() string {
1817	return "OperationInputValidation"
1818}
1819
1820func (m *validateOpUpdateBasePathMapping) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1821	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1822) {
1823	input, ok := in.Parameters.(*UpdateBasePathMappingInput)
1824	if !ok {
1825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1826	}
1827	if err := validateOpUpdateBasePathMappingInput(input); err != nil {
1828		return out, metadata, err
1829	}
1830	return next.HandleInitialize(ctx, in)
1831}
1832
1833type validateOpUpdateClientCertificate struct {
1834}
1835
1836func (*validateOpUpdateClientCertificate) ID() string {
1837	return "OperationInputValidation"
1838}
1839
1840func (m *validateOpUpdateClientCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1841	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1842) {
1843	input, ok := in.Parameters.(*UpdateClientCertificateInput)
1844	if !ok {
1845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1846	}
1847	if err := validateOpUpdateClientCertificateInput(input); err != nil {
1848		return out, metadata, err
1849	}
1850	return next.HandleInitialize(ctx, in)
1851}
1852
1853type validateOpUpdateDeployment struct {
1854}
1855
1856func (*validateOpUpdateDeployment) ID() string {
1857	return "OperationInputValidation"
1858}
1859
1860func (m *validateOpUpdateDeployment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1861	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1862) {
1863	input, ok := in.Parameters.(*UpdateDeploymentInput)
1864	if !ok {
1865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1866	}
1867	if err := validateOpUpdateDeploymentInput(input); err != nil {
1868		return out, metadata, err
1869	}
1870	return next.HandleInitialize(ctx, in)
1871}
1872
1873type validateOpUpdateDocumentationPart struct {
1874}
1875
1876func (*validateOpUpdateDocumentationPart) ID() string {
1877	return "OperationInputValidation"
1878}
1879
1880func (m *validateOpUpdateDocumentationPart) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1881	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1882) {
1883	input, ok := in.Parameters.(*UpdateDocumentationPartInput)
1884	if !ok {
1885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1886	}
1887	if err := validateOpUpdateDocumentationPartInput(input); err != nil {
1888		return out, metadata, err
1889	}
1890	return next.HandleInitialize(ctx, in)
1891}
1892
1893type validateOpUpdateDocumentationVersion struct {
1894}
1895
1896func (*validateOpUpdateDocumentationVersion) ID() string {
1897	return "OperationInputValidation"
1898}
1899
1900func (m *validateOpUpdateDocumentationVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1901	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1902) {
1903	input, ok := in.Parameters.(*UpdateDocumentationVersionInput)
1904	if !ok {
1905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1906	}
1907	if err := validateOpUpdateDocumentationVersionInput(input); err != nil {
1908		return out, metadata, err
1909	}
1910	return next.HandleInitialize(ctx, in)
1911}
1912
1913type validateOpUpdateDomainName struct {
1914}
1915
1916func (*validateOpUpdateDomainName) ID() string {
1917	return "OperationInputValidation"
1918}
1919
1920func (m *validateOpUpdateDomainName) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1921	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1922) {
1923	input, ok := in.Parameters.(*UpdateDomainNameInput)
1924	if !ok {
1925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1926	}
1927	if err := validateOpUpdateDomainNameInput(input); err != nil {
1928		return out, metadata, err
1929	}
1930	return next.HandleInitialize(ctx, in)
1931}
1932
1933type validateOpUpdateGatewayResponse struct {
1934}
1935
1936func (*validateOpUpdateGatewayResponse) ID() string {
1937	return "OperationInputValidation"
1938}
1939
1940func (m *validateOpUpdateGatewayResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1941	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1942) {
1943	input, ok := in.Parameters.(*UpdateGatewayResponseInput)
1944	if !ok {
1945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1946	}
1947	if err := validateOpUpdateGatewayResponseInput(input); err != nil {
1948		return out, metadata, err
1949	}
1950	return next.HandleInitialize(ctx, in)
1951}
1952
1953type validateOpUpdateIntegration struct {
1954}
1955
1956func (*validateOpUpdateIntegration) ID() string {
1957	return "OperationInputValidation"
1958}
1959
1960func (m *validateOpUpdateIntegration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1961	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1962) {
1963	input, ok := in.Parameters.(*UpdateIntegrationInput)
1964	if !ok {
1965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1966	}
1967	if err := validateOpUpdateIntegrationInput(input); err != nil {
1968		return out, metadata, err
1969	}
1970	return next.HandleInitialize(ctx, in)
1971}
1972
1973type validateOpUpdateIntegrationResponse struct {
1974}
1975
1976func (*validateOpUpdateIntegrationResponse) ID() string {
1977	return "OperationInputValidation"
1978}
1979
1980func (m *validateOpUpdateIntegrationResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1981	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1982) {
1983	input, ok := in.Parameters.(*UpdateIntegrationResponseInput)
1984	if !ok {
1985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1986	}
1987	if err := validateOpUpdateIntegrationResponseInput(input); err != nil {
1988		return out, metadata, err
1989	}
1990	return next.HandleInitialize(ctx, in)
1991}
1992
1993type validateOpUpdateMethod struct {
1994}
1995
1996func (*validateOpUpdateMethod) ID() string {
1997	return "OperationInputValidation"
1998}
1999
2000func (m *validateOpUpdateMethod) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2001	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2002) {
2003	input, ok := in.Parameters.(*UpdateMethodInput)
2004	if !ok {
2005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2006	}
2007	if err := validateOpUpdateMethodInput(input); err != nil {
2008		return out, metadata, err
2009	}
2010	return next.HandleInitialize(ctx, in)
2011}
2012
2013type validateOpUpdateMethodResponse struct {
2014}
2015
2016func (*validateOpUpdateMethodResponse) ID() string {
2017	return "OperationInputValidation"
2018}
2019
2020func (m *validateOpUpdateMethodResponse) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2021	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2022) {
2023	input, ok := in.Parameters.(*UpdateMethodResponseInput)
2024	if !ok {
2025		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2026	}
2027	if err := validateOpUpdateMethodResponseInput(input); err != nil {
2028		return out, metadata, err
2029	}
2030	return next.HandleInitialize(ctx, in)
2031}
2032
2033type validateOpUpdateModel struct {
2034}
2035
2036func (*validateOpUpdateModel) ID() string {
2037	return "OperationInputValidation"
2038}
2039
2040func (m *validateOpUpdateModel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2041	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2042) {
2043	input, ok := in.Parameters.(*UpdateModelInput)
2044	if !ok {
2045		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2046	}
2047	if err := validateOpUpdateModelInput(input); err != nil {
2048		return out, metadata, err
2049	}
2050	return next.HandleInitialize(ctx, in)
2051}
2052
2053type validateOpUpdateRequestValidator struct {
2054}
2055
2056func (*validateOpUpdateRequestValidator) ID() string {
2057	return "OperationInputValidation"
2058}
2059
2060func (m *validateOpUpdateRequestValidator) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2061	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2062) {
2063	input, ok := in.Parameters.(*UpdateRequestValidatorInput)
2064	if !ok {
2065		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2066	}
2067	if err := validateOpUpdateRequestValidatorInput(input); err != nil {
2068		return out, metadata, err
2069	}
2070	return next.HandleInitialize(ctx, in)
2071}
2072
2073type validateOpUpdateResource struct {
2074}
2075
2076func (*validateOpUpdateResource) ID() string {
2077	return "OperationInputValidation"
2078}
2079
2080func (m *validateOpUpdateResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2081	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2082) {
2083	input, ok := in.Parameters.(*UpdateResourceInput)
2084	if !ok {
2085		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2086	}
2087	if err := validateOpUpdateResourceInput(input); err != nil {
2088		return out, metadata, err
2089	}
2090	return next.HandleInitialize(ctx, in)
2091}
2092
2093type validateOpUpdateRestApi struct {
2094}
2095
2096func (*validateOpUpdateRestApi) ID() string {
2097	return "OperationInputValidation"
2098}
2099
2100func (m *validateOpUpdateRestApi) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2102) {
2103	input, ok := in.Parameters.(*UpdateRestApiInput)
2104	if !ok {
2105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2106	}
2107	if err := validateOpUpdateRestApiInput(input); err != nil {
2108		return out, metadata, err
2109	}
2110	return next.HandleInitialize(ctx, in)
2111}
2112
2113type validateOpUpdateStage struct {
2114}
2115
2116func (*validateOpUpdateStage) ID() string {
2117	return "OperationInputValidation"
2118}
2119
2120func (m *validateOpUpdateStage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2122) {
2123	input, ok := in.Parameters.(*UpdateStageInput)
2124	if !ok {
2125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2126	}
2127	if err := validateOpUpdateStageInput(input); err != nil {
2128		return out, metadata, err
2129	}
2130	return next.HandleInitialize(ctx, in)
2131}
2132
2133type validateOpUpdateUsage struct {
2134}
2135
2136func (*validateOpUpdateUsage) ID() string {
2137	return "OperationInputValidation"
2138}
2139
2140func (m *validateOpUpdateUsage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2142) {
2143	input, ok := in.Parameters.(*UpdateUsageInput)
2144	if !ok {
2145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2146	}
2147	if err := validateOpUpdateUsageInput(input); err != nil {
2148		return out, metadata, err
2149	}
2150	return next.HandleInitialize(ctx, in)
2151}
2152
2153type validateOpUpdateUsagePlan struct {
2154}
2155
2156func (*validateOpUpdateUsagePlan) ID() string {
2157	return "OperationInputValidation"
2158}
2159
2160func (m *validateOpUpdateUsagePlan) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2161	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2162) {
2163	input, ok := in.Parameters.(*UpdateUsagePlanInput)
2164	if !ok {
2165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2166	}
2167	if err := validateOpUpdateUsagePlanInput(input); err != nil {
2168		return out, metadata, err
2169	}
2170	return next.HandleInitialize(ctx, in)
2171}
2172
2173type validateOpUpdateVpcLink struct {
2174}
2175
2176func (*validateOpUpdateVpcLink) ID() string {
2177	return "OperationInputValidation"
2178}
2179
2180func (m *validateOpUpdateVpcLink) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
2181	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
2182) {
2183	input, ok := in.Parameters.(*UpdateVpcLinkInput)
2184	if !ok {
2185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
2186	}
2187	if err := validateOpUpdateVpcLinkInput(input); err != nil {
2188		return out, metadata, err
2189	}
2190	return next.HandleInitialize(ctx, in)
2191}
2192
2193func addOpCreateAuthorizerValidationMiddleware(stack *middleware.Stack) error {
2194	return stack.Initialize.Add(&validateOpCreateAuthorizer{}, middleware.After)
2195}
2196
2197func addOpCreateBasePathMappingValidationMiddleware(stack *middleware.Stack) error {
2198	return stack.Initialize.Add(&validateOpCreateBasePathMapping{}, middleware.After)
2199}
2200
2201func addOpCreateDeploymentValidationMiddleware(stack *middleware.Stack) error {
2202	return stack.Initialize.Add(&validateOpCreateDeployment{}, middleware.After)
2203}
2204
2205func addOpCreateDocumentationPartValidationMiddleware(stack *middleware.Stack) error {
2206	return stack.Initialize.Add(&validateOpCreateDocumentationPart{}, middleware.After)
2207}
2208
2209func addOpCreateDocumentationVersionValidationMiddleware(stack *middleware.Stack) error {
2210	return stack.Initialize.Add(&validateOpCreateDocumentationVersion{}, middleware.After)
2211}
2212
2213func addOpCreateDomainNameValidationMiddleware(stack *middleware.Stack) error {
2214	return stack.Initialize.Add(&validateOpCreateDomainName{}, middleware.After)
2215}
2216
2217func addOpCreateModelValidationMiddleware(stack *middleware.Stack) error {
2218	return stack.Initialize.Add(&validateOpCreateModel{}, middleware.After)
2219}
2220
2221func addOpCreateRequestValidatorValidationMiddleware(stack *middleware.Stack) error {
2222	return stack.Initialize.Add(&validateOpCreateRequestValidator{}, middleware.After)
2223}
2224
2225func addOpCreateResourceValidationMiddleware(stack *middleware.Stack) error {
2226	return stack.Initialize.Add(&validateOpCreateResource{}, middleware.After)
2227}
2228
2229func addOpCreateRestApiValidationMiddleware(stack *middleware.Stack) error {
2230	return stack.Initialize.Add(&validateOpCreateRestApi{}, middleware.After)
2231}
2232
2233func addOpCreateStageValidationMiddleware(stack *middleware.Stack) error {
2234	return stack.Initialize.Add(&validateOpCreateStage{}, middleware.After)
2235}
2236
2237func addOpCreateUsagePlanValidationMiddleware(stack *middleware.Stack) error {
2238	return stack.Initialize.Add(&validateOpCreateUsagePlan{}, middleware.After)
2239}
2240
2241func addOpCreateUsagePlanKeyValidationMiddleware(stack *middleware.Stack) error {
2242	return stack.Initialize.Add(&validateOpCreateUsagePlanKey{}, middleware.After)
2243}
2244
2245func addOpCreateVpcLinkValidationMiddleware(stack *middleware.Stack) error {
2246	return stack.Initialize.Add(&validateOpCreateVpcLink{}, middleware.After)
2247}
2248
2249func addOpDeleteApiKeyValidationMiddleware(stack *middleware.Stack) error {
2250	return stack.Initialize.Add(&validateOpDeleteApiKey{}, middleware.After)
2251}
2252
2253func addOpDeleteAuthorizerValidationMiddleware(stack *middleware.Stack) error {
2254	return stack.Initialize.Add(&validateOpDeleteAuthorizer{}, middleware.After)
2255}
2256
2257func addOpDeleteBasePathMappingValidationMiddleware(stack *middleware.Stack) error {
2258	return stack.Initialize.Add(&validateOpDeleteBasePathMapping{}, middleware.After)
2259}
2260
2261func addOpDeleteClientCertificateValidationMiddleware(stack *middleware.Stack) error {
2262	return stack.Initialize.Add(&validateOpDeleteClientCertificate{}, middleware.After)
2263}
2264
2265func addOpDeleteDeploymentValidationMiddleware(stack *middleware.Stack) error {
2266	return stack.Initialize.Add(&validateOpDeleteDeployment{}, middleware.After)
2267}
2268
2269func addOpDeleteDocumentationPartValidationMiddleware(stack *middleware.Stack) error {
2270	return stack.Initialize.Add(&validateOpDeleteDocumentationPart{}, middleware.After)
2271}
2272
2273func addOpDeleteDocumentationVersionValidationMiddleware(stack *middleware.Stack) error {
2274	return stack.Initialize.Add(&validateOpDeleteDocumentationVersion{}, middleware.After)
2275}
2276
2277func addOpDeleteDomainNameValidationMiddleware(stack *middleware.Stack) error {
2278	return stack.Initialize.Add(&validateOpDeleteDomainName{}, middleware.After)
2279}
2280
2281func addOpDeleteGatewayResponseValidationMiddleware(stack *middleware.Stack) error {
2282	return stack.Initialize.Add(&validateOpDeleteGatewayResponse{}, middleware.After)
2283}
2284
2285func addOpDeleteIntegrationValidationMiddleware(stack *middleware.Stack) error {
2286	return stack.Initialize.Add(&validateOpDeleteIntegration{}, middleware.After)
2287}
2288
2289func addOpDeleteIntegrationResponseValidationMiddleware(stack *middleware.Stack) error {
2290	return stack.Initialize.Add(&validateOpDeleteIntegrationResponse{}, middleware.After)
2291}
2292
2293func addOpDeleteMethodValidationMiddleware(stack *middleware.Stack) error {
2294	return stack.Initialize.Add(&validateOpDeleteMethod{}, middleware.After)
2295}
2296
2297func addOpDeleteMethodResponseValidationMiddleware(stack *middleware.Stack) error {
2298	return stack.Initialize.Add(&validateOpDeleteMethodResponse{}, middleware.After)
2299}
2300
2301func addOpDeleteModelValidationMiddleware(stack *middleware.Stack) error {
2302	return stack.Initialize.Add(&validateOpDeleteModel{}, middleware.After)
2303}
2304
2305func addOpDeleteRequestValidatorValidationMiddleware(stack *middleware.Stack) error {
2306	return stack.Initialize.Add(&validateOpDeleteRequestValidator{}, middleware.After)
2307}
2308
2309func addOpDeleteResourceValidationMiddleware(stack *middleware.Stack) error {
2310	return stack.Initialize.Add(&validateOpDeleteResource{}, middleware.After)
2311}
2312
2313func addOpDeleteRestApiValidationMiddleware(stack *middleware.Stack) error {
2314	return stack.Initialize.Add(&validateOpDeleteRestApi{}, middleware.After)
2315}
2316
2317func addOpDeleteStageValidationMiddleware(stack *middleware.Stack) error {
2318	return stack.Initialize.Add(&validateOpDeleteStage{}, middleware.After)
2319}
2320
2321func addOpDeleteUsagePlanValidationMiddleware(stack *middleware.Stack) error {
2322	return stack.Initialize.Add(&validateOpDeleteUsagePlan{}, middleware.After)
2323}
2324
2325func addOpDeleteUsagePlanKeyValidationMiddleware(stack *middleware.Stack) error {
2326	return stack.Initialize.Add(&validateOpDeleteUsagePlanKey{}, middleware.After)
2327}
2328
2329func addOpDeleteVpcLinkValidationMiddleware(stack *middleware.Stack) error {
2330	return stack.Initialize.Add(&validateOpDeleteVpcLink{}, middleware.After)
2331}
2332
2333func addOpFlushStageAuthorizersCacheValidationMiddleware(stack *middleware.Stack) error {
2334	return stack.Initialize.Add(&validateOpFlushStageAuthorizersCache{}, middleware.After)
2335}
2336
2337func addOpFlushStageCacheValidationMiddleware(stack *middleware.Stack) error {
2338	return stack.Initialize.Add(&validateOpFlushStageCache{}, middleware.After)
2339}
2340
2341func addOpGetApiKeyValidationMiddleware(stack *middleware.Stack) error {
2342	return stack.Initialize.Add(&validateOpGetApiKey{}, middleware.After)
2343}
2344
2345func addOpGetAuthorizerValidationMiddleware(stack *middleware.Stack) error {
2346	return stack.Initialize.Add(&validateOpGetAuthorizer{}, middleware.After)
2347}
2348
2349func addOpGetAuthorizersValidationMiddleware(stack *middleware.Stack) error {
2350	return stack.Initialize.Add(&validateOpGetAuthorizers{}, middleware.After)
2351}
2352
2353func addOpGetBasePathMappingValidationMiddleware(stack *middleware.Stack) error {
2354	return stack.Initialize.Add(&validateOpGetBasePathMapping{}, middleware.After)
2355}
2356
2357func addOpGetBasePathMappingsValidationMiddleware(stack *middleware.Stack) error {
2358	return stack.Initialize.Add(&validateOpGetBasePathMappings{}, middleware.After)
2359}
2360
2361func addOpGetClientCertificateValidationMiddleware(stack *middleware.Stack) error {
2362	return stack.Initialize.Add(&validateOpGetClientCertificate{}, middleware.After)
2363}
2364
2365func addOpGetDeploymentValidationMiddleware(stack *middleware.Stack) error {
2366	return stack.Initialize.Add(&validateOpGetDeployment{}, middleware.After)
2367}
2368
2369func addOpGetDeploymentsValidationMiddleware(stack *middleware.Stack) error {
2370	return stack.Initialize.Add(&validateOpGetDeployments{}, middleware.After)
2371}
2372
2373func addOpGetDocumentationPartValidationMiddleware(stack *middleware.Stack) error {
2374	return stack.Initialize.Add(&validateOpGetDocumentationPart{}, middleware.After)
2375}
2376
2377func addOpGetDocumentationPartsValidationMiddleware(stack *middleware.Stack) error {
2378	return stack.Initialize.Add(&validateOpGetDocumentationParts{}, middleware.After)
2379}
2380
2381func addOpGetDocumentationVersionValidationMiddleware(stack *middleware.Stack) error {
2382	return stack.Initialize.Add(&validateOpGetDocumentationVersion{}, middleware.After)
2383}
2384
2385func addOpGetDocumentationVersionsValidationMiddleware(stack *middleware.Stack) error {
2386	return stack.Initialize.Add(&validateOpGetDocumentationVersions{}, middleware.After)
2387}
2388
2389func addOpGetDomainNameValidationMiddleware(stack *middleware.Stack) error {
2390	return stack.Initialize.Add(&validateOpGetDomainName{}, middleware.After)
2391}
2392
2393func addOpGetExportValidationMiddleware(stack *middleware.Stack) error {
2394	return stack.Initialize.Add(&validateOpGetExport{}, middleware.After)
2395}
2396
2397func addOpGetGatewayResponseValidationMiddleware(stack *middleware.Stack) error {
2398	return stack.Initialize.Add(&validateOpGetGatewayResponse{}, middleware.After)
2399}
2400
2401func addOpGetGatewayResponsesValidationMiddleware(stack *middleware.Stack) error {
2402	return stack.Initialize.Add(&validateOpGetGatewayResponses{}, middleware.After)
2403}
2404
2405func addOpGetIntegrationValidationMiddleware(stack *middleware.Stack) error {
2406	return stack.Initialize.Add(&validateOpGetIntegration{}, middleware.After)
2407}
2408
2409func addOpGetIntegrationResponseValidationMiddleware(stack *middleware.Stack) error {
2410	return stack.Initialize.Add(&validateOpGetIntegrationResponse{}, middleware.After)
2411}
2412
2413func addOpGetMethodValidationMiddleware(stack *middleware.Stack) error {
2414	return stack.Initialize.Add(&validateOpGetMethod{}, middleware.After)
2415}
2416
2417func addOpGetMethodResponseValidationMiddleware(stack *middleware.Stack) error {
2418	return stack.Initialize.Add(&validateOpGetMethodResponse{}, middleware.After)
2419}
2420
2421func addOpGetModelValidationMiddleware(stack *middleware.Stack) error {
2422	return stack.Initialize.Add(&validateOpGetModel{}, middleware.After)
2423}
2424
2425func addOpGetModelsValidationMiddleware(stack *middleware.Stack) error {
2426	return stack.Initialize.Add(&validateOpGetModels{}, middleware.After)
2427}
2428
2429func addOpGetModelTemplateValidationMiddleware(stack *middleware.Stack) error {
2430	return stack.Initialize.Add(&validateOpGetModelTemplate{}, middleware.After)
2431}
2432
2433func addOpGetRequestValidatorValidationMiddleware(stack *middleware.Stack) error {
2434	return stack.Initialize.Add(&validateOpGetRequestValidator{}, middleware.After)
2435}
2436
2437func addOpGetRequestValidatorsValidationMiddleware(stack *middleware.Stack) error {
2438	return stack.Initialize.Add(&validateOpGetRequestValidators{}, middleware.After)
2439}
2440
2441func addOpGetResourceValidationMiddleware(stack *middleware.Stack) error {
2442	return stack.Initialize.Add(&validateOpGetResource{}, middleware.After)
2443}
2444
2445func addOpGetResourcesValidationMiddleware(stack *middleware.Stack) error {
2446	return stack.Initialize.Add(&validateOpGetResources{}, middleware.After)
2447}
2448
2449func addOpGetRestApiValidationMiddleware(stack *middleware.Stack) error {
2450	return stack.Initialize.Add(&validateOpGetRestApi{}, middleware.After)
2451}
2452
2453func addOpGetSdkValidationMiddleware(stack *middleware.Stack) error {
2454	return stack.Initialize.Add(&validateOpGetSdk{}, middleware.After)
2455}
2456
2457func addOpGetSdkTypeValidationMiddleware(stack *middleware.Stack) error {
2458	return stack.Initialize.Add(&validateOpGetSdkType{}, middleware.After)
2459}
2460
2461func addOpGetStageValidationMiddleware(stack *middleware.Stack) error {
2462	return stack.Initialize.Add(&validateOpGetStage{}, middleware.After)
2463}
2464
2465func addOpGetStagesValidationMiddleware(stack *middleware.Stack) error {
2466	return stack.Initialize.Add(&validateOpGetStages{}, middleware.After)
2467}
2468
2469func addOpGetTagsValidationMiddleware(stack *middleware.Stack) error {
2470	return stack.Initialize.Add(&validateOpGetTags{}, middleware.After)
2471}
2472
2473func addOpGetUsageValidationMiddleware(stack *middleware.Stack) error {
2474	return stack.Initialize.Add(&validateOpGetUsage{}, middleware.After)
2475}
2476
2477func addOpGetUsagePlanValidationMiddleware(stack *middleware.Stack) error {
2478	return stack.Initialize.Add(&validateOpGetUsagePlan{}, middleware.After)
2479}
2480
2481func addOpGetUsagePlanKeyValidationMiddleware(stack *middleware.Stack) error {
2482	return stack.Initialize.Add(&validateOpGetUsagePlanKey{}, middleware.After)
2483}
2484
2485func addOpGetUsagePlanKeysValidationMiddleware(stack *middleware.Stack) error {
2486	return stack.Initialize.Add(&validateOpGetUsagePlanKeys{}, middleware.After)
2487}
2488
2489func addOpGetVpcLinkValidationMiddleware(stack *middleware.Stack) error {
2490	return stack.Initialize.Add(&validateOpGetVpcLink{}, middleware.After)
2491}
2492
2493func addOpImportApiKeysValidationMiddleware(stack *middleware.Stack) error {
2494	return stack.Initialize.Add(&validateOpImportApiKeys{}, middleware.After)
2495}
2496
2497func addOpImportDocumentationPartsValidationMiddleware(stack *middleware.Stack) error {
2498	return stack.Initialize.Add(&validateOpImportDocumentationParts{}, middleware.After)
2499}
2500
2501func addOpImportRestApiValidationMiddleware(stack *middleware.Stack) error {
2502	return stack.Initialize.Add(&validateOpImportRestApi{}, middleware.After)
2503}
2504
2505func addOpPutGatewayResponseValidationMiddleware(stack *middleware.Stack) error {
2506	return stack.Initialize.Add(&validateOpPutGatewayResponse{}, middleware.After)
2507}
2508
2509func addOpPutIntegrationValidationMiddleware(stack *middleware.Stack) error {
2510	return stack.Initialize.Add(&validateOpPutIntegration{}, middleware.After)
2511}
2512
2513func addOpPutIntegrationResponseValidationMiddleware(stack *middleware.Stack) error {
2514	return stack.Initialize.Add(&validateOpPutIntegrationResponse{}, middleware.After)
2515}
2516
2517func addOpPutMethodValidationMiddleware(stack *middleware.Stack) error {
2518	return stack.Initialize.Add(&validateOpPutMethod{}, middleware.After)
2519}
2520
2521func addOpPutMethodResponseValidationMiddleware(stack *middleware.Stack) error {
2522	return stack.Initialize.Add(&validateOpPutMethodResponse{}, middleware.After)
2523}
2524
2525func addOpPutRestApiValidationMiddleware(stack *middleware.Stack) error {
2526	return stack.Initialize.Add(&validateOpPutRestApi{}, middleware.After)
2527}
2528
2529func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
2530	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
2531}
2532
2533func addOpTestInvokeAuthorizerValidationMiddleware(stack *middleware.Stack) error {
2534	return stack.Initialize.Add(&validateOpTestInvokeAuthorizer{}, middleware.After)
2535}
2536
2537func addOpTestInvokeMethodValidationMiddleware(stack *middleware.Stack) error {
2538	return stack.Initialize.Add(&validateOpTestInvokeMethod{}, middleware.After)
2539}
2540
2541func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
2542	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
2543}
2544
2545func addOpUpdateApiKeyValidationMiddleware(stack *middleware.Stack) error {
2546	return stack.Initialize.Add(&validateOpUpdateApiKey{}, middleware.After)
2547}
2548
2549func addOpUpdateAuthorizerValidationMiddleware(stack *middleware.Stack) error {
2550	return stack.Initialize.Add(&validateOpUpdateAuthorizer{}, middleware.After)
2551}
2552
2553func addOpUpdateBasePathMappingValidationMiddleware(stack *middleware.Stack) error {
2554	return stack.Initialize.Add(&validateOpUpdateBasePathMapping{}, middleware.After)
2555}
2556
2557func addOpUpdateClientCertificateValidationMiddleware(stack *middleware.Stack) error {
2558	return stack.Initialize.Add(&validateOpUpdateClientCertificate{}, middleware.After)
2559}
2560
2561func addOpUpdateDeploymentValidationMiddleware(stack *middleware.Stack) error {
2562	return stack.Initialize.Add(&validateOpUpdateDeployment{}, middleware.After)
2563}
2564
2565func addOpUpdateDocumentationPartValidationMiddleware(stack *middleware.Stack) error {
2566	return stack.Initialize.Add(&validateOpUpdateDocumentationPart{}, middleware.After)
2567}
2568
2569func addOpUpdateDocumentationVersionValidationMiddleware(stack *middleware.Stack) error {
2570	return stack.Initialize.Add(&validateOpUpdateDocumentationVersion{}, middleware.After)
2571}
2572
2573func addOpUpdateDomainNameValidationMiddleware(stack *middleware.Stack) error {
2574	return stack.Initialize.Add(&validateOpUpdateDomainName{}, middleware.After)
2575}
2576
2577func addOpUpdateGatewayResponseValidationMiddleware(stack *middleware.Stack) error {
2578	return stack.Initialize.Add(&validateOpUpdateGatewayResponse{}, middleware.After)
2579}
2580
2581func addOpUpdateIntegrationValidationMiddleware(stack *middleware.Stack) error {
2582	return stack.Initialize.Add(&validateOpUpdateIntegration{}, middleware.After)
2583}
2584
2585func addOpUpdateIntegrationResponseValidationMiddleware(stack *middleware.Stack) error {
2586	return stack.Initialize.Add(&validateOpUpdateIntegrationResponse{}, middleware.After)
2587}
2588
2589func addOpUpdateMethodValidationMiddleware(stack *middleware.Stack) error {
2590	return stack.Initialize.Add(&validateOpUpdateMethod{}, middleware.After)
2591}
2592
2593func addOpUpdateMethodResponseValidationMiddleware(stack *middleware.Stack) error {
2594	return stack.Initialize.Add(&validateOpUpdateMethodResponse{}, middleware.After)
2595}
2596
2597func addOpUpdateModelValidationMiddleware(stack *middleware.Stack) error {
2598	return stack.Initialize.Add(&validateOpUpdateModel{}, middleware.After)
2599}
2600
2601func addOpUpdateRequestValidatorValidationMiddleware(stack *middleware.Stack) error {
2602	return stack.Initialize.Add(&validateOpUpdateRequestValidator{}, middleware.After)
2603}
2604
2605func addOpUpdateResourceValidationMiddleware(stack *middleware.Stack) error {
2606	return stack.Initialize.Add(&validateOpUpdateResource{}, middleware.After)
2607}
2608
2609func addOpUpdateRestApiValidationMiddleware(stack *middleware.Stack) error {
2610	return stack.Initialize.Add(&validateOpUpdateRestApi{}, middleware.After)
2611}
2612
2613func addOpUpdateStageValidationMiddleware(stack *middleware.Stack) error {
2614	return stack.Initialize.Add(&validateOpUpdateStage{}, middleware.After)
2615}
2616
2617func addOpUpdateUsageValidationMiddleware(stack *middleware.Stack) error {
2618	return stack.Initialize.Add(&validateOpUpdateUsage{}, middleware.After)
2619}
2620
2621func addOpUpdateUsagePlanValidationMiddleware(stack *middleware.Stack) error {
2622	return stack.Initialize.Add(&validateOpUpdateUsagePlan{}, middleware.After)
2623}
2624
2625func addOpUpdateVpcLinkValidationMiddleware(stack *middleware.Stack) error {
2626	return stack.Initialize.Add(&validateOpUpdateVpcLink{}, middleware.After)
2627}
2628
2629func validateDocumentationPartLocation(v *types.DocumentationPartLocation) error {
2630	if v == nil {
2631		return nil
2632	}
2633	invalidParams := smithy.InvalidParamsError{Context: "DocumentationPartLocation"}
2634	if len(v.Type) == 0 {
2635		invalidParams.Add(smithy.NewErrParamRequired("Type"))
2636	}
2637	if invalidParams.Len() > 0 {
2638		return invalidParams
2639	} else {
2640		return nil
2641	}
2642}
2643
2644func validateOpCreateAuthorizerInput(v *CreateAuthorizerInput) error {
2645	if v == nil {
2646		return nil
2647	}
2648	invalidParams := smithy.InvalidParamsError{Context: "CreateAuthorizerInput"}
2649	if v.RestApiId == nil {
2650		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
2651	}
2652	if v.Name == nil {
2653		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2654	}
2655	if len(v.Type) == 0 {
2656		invalidParams.Add(smithy.NewErrParamRequired("Type"))
2657	}
2658	if invalidParams.Len() > 0 {
2659		return invalidParams
2660	} else {
2661		return nil
2662	}
2663}
2664
2665func validateOpCreateBasePathMappingInput(v *CreateBasePathMappingInput) error {
2666	if v == nil {
2667		return nil
2668	}
2669	invalidParams := smithy.InvalidParamsError{Context: "CreateBasePathMappingInput"}
2670	if v.DomainName == nil {
2671		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
2672	}
2673	if v.RestApiId == nil {
2674		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
2675	}
2676	if invalidParams.Len() > 0 {
2677		return invalidParams
2678	} else {
2679		return nil
2680	}
2681}
2682
2683func validateOpCreateDeploymentInput(v *CreateDeploymentInput) error {
2684	if v == nil {
2685		return nil
2686	}
2687	invalidParams := smithy.InvalidParamsError{Context: "CreateDeploymentInput"}
2688	if v.RestApiId == nil {
2689		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
2690	}
2691	if invalidParams.Len() > 0 {
2692		return invalidParams
2693	} else {
2694		return nil
2695	}
2696}
2697
2698func validateOpCreateDocumentationPartInput(v *CreateDocumentationPartInput) error {
2699	if v == nil {
2700		return nil
2701	}
2702	invalidParams := smithy.InvalidParamsError{Context: "CreateDocumentationPartInput"}
2703	if v.RestApiId == nil {
2704		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
2705	}
2706	if v.Location == nil {
2707		invalidParams.Add(smithy.NewErrParamRequired("Location"))
2708	} else if v.Location != nil {
2709		if err := validateDocumentationPartLocation(v.Location); err != nil {
2710			invalidParams.AddNested("Location", err.(smithy.InvalidParamsError))
2711		}
2712	}
2713	if v.Properties == nil {
2714		invalidParams.Add(smithy.NewErrParamRequired("Properties"))
2715	}
2716	if invalidParams.Len() > 0 {
2717		return invalidParams
2718	} else {
2719		return nil
2720	}
2721}
2722
2723func validateOpCreateDocumentationVersionInput(v *CreateDocumentationVersionInput) error {
2724	if v == nil {
2725		return nil
2726	}
2727	invalidParams := smithy.InvalidParamsError{Context: "CreateDocumentationVersionInput"}
2728	if v.RestApiId == nil {
2729		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
2730	}
2731	if v.DocumentationVersion == nil {
2732		invalidParams.Add(smithy.NewErrParamRequired("DocumentationVersion"))
2733	}
2734	if invalidParams.Len() > 0 {
2735		return invalidParams
2736	} else {
2737		return nil
2738	}
2739}
2740
2741func validateOpCreateDomainNameInput(v *CreateDomainNameInput) error {
2742	if v == nil {
2743		return nil
2744	}
2745	invalidParams := smithy.InvalidParamsError{Context: "CreateDomainNameInput"}
2746	if v.DomainName == nil {
2747		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
2748	}
2749	if invalidParams.Len() > 0 {
2750		return invalidParams
2751	} else {
2752		return nil
2753	}
2754}
2755
2756func validateOpCreateModelInput(v *CreateModelInput) error {
2757	if v == nil {
2758		return nil
2759	}
2760	invalidParams := smithy.InvalidParamsError{Context: "CreateModelInput"}
2761	if v.RestApiId == nil {
2762		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
2763	}
2764	if v.Name == nil {
2765		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2766	}
2767	if v.ContentType == nil {
2768		invalidParams.Add(smithy.NewErrParamRequired("ContentType"))
2769	}
2770	if invalidParams.Len() > 0 {
2771		return invalidParams
2772	} else {
2773		return nil
2774	}
2775}
2776
2777func validateOpCreateRequestValidatorInput(v *CreateRequestValidatorInput) error {
2778	if v == nil {
2779		return nil
2780	}
2781	invalidParams := smithy.InvalidParamsError{Context: "CreateRequestValidatorInput"}
2782	if v.RestApiId == nil {
2783		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
2784	}
2785	if invalidParams.Len() > 0 {
2786		return invalidParams
2787	} else {
2788		return nil
2789	}
2790}
2791
2792func validateOpCreateResourceInput(v *CreateResourceInput) error {
2793	if v == nil {
2794		return nil
2795	}
2796	invalidParams := smithy.InvalidParamsError{Context: "CreateResourceInput"}
2797	if v.RestApiId == nil {
2798		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
2799	}
2800	if v.ParentId == nil {
2801		invalidParams.Add(smithy.NewErrParamRequired("ParentId"))
2802	}
2803	if v.PathPart == nil {
2804		invalidParams.Add(smithy.NewErrParamRequired("PathPart"))
2805	}
2806	if invalidParams.Len() > 0 {
2807		return invalidParams
2808	} else {
2809		return nil
2810	}
2811}
2812
2813func validateOpCreateRestApiInput(v *CreateRestApiInput) error {
2814	if v == nil {
2815		return nil
2816	}
2817	invalidParams := smithy.InvalidParamsError{Context: "CreateRestApiInput"}
2818	if v.Name == nil {
2819		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2820	}
2821	if invalidParams.Len() > 0 {
2822		return invalidParams
2823	} else {
2824		return nil
2825	}
2826}
2827
2828func validateOpCreateStageInput(v *CreateStageInput) error {
2829	if v == nil {
2830		return nil
2831	}
2832	invalidParams := smithy.InvalidParamsError{Context: "CreateStageInput"}
2833	if v.RestApiId == nil {
2834		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
2835	}
2836	if v.StageName == nil {
2837		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
2838	}
2839	if v.DeploymentId == nil {
2840		invalidParams.Add(smithy.NewErrParamRequired("DeploymentId"))
2841	}
2842	if invalidParams.Len() > 0 {
2843		return invalidParams
2844	} else {
2845		return nil
2846	}
2847}
2848
2849func validateOpCreateUsagePlanInput(v *CreateUsagePlanInput) error {
2850	if v == nil {
2851		return nil
2852	}
2853	invalidParams := smithy.InvalidParamsError{Context: "CreateUsagePlanInput"}
2854	if v.Name == nil {
2855		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2856	}
2857	if invalidParams.Len() > 0 {
2858		return invalidParams
2859	} else {
2860		return nil
2861	}
2862}
2863
2864func validateOpCreateUsagePlanKeyInput(v *CreateUsagePlanKeyInput) error {
2865	if v == nil {
2866		return nil
2867	}
2868	invalidParams := smithy.InvalidParamsError{Context: "CreateUsagePlanKeyInput"}
2869	if v.UsagePlanId == nil {
2870		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
2871	}
2872	if v.KeyId == nil {
2873		invalidParams.Add(smithy.NewErrParamRequired("KeyId"))
2874	}
2875	if v.KeyType == nil {
2876		invalidParams.Add(smithy.NewErrParamRequired("KeyType"))
2877	}
2878	if invalidParams.Len() > 0 {
2879		return invalidParams
2880	} else {
2881		return nil
2882	}
2883}
2884
2885func validateOpCreateVpcLinkInput(v *CreateVpcLinkInput) error {
2886	if v == nil {
2887		return nil
2888	}
2889	invalidParams := smithy.InvalidParamsError{Context: "CreateVpcLinkInput"}
2890	if v.Name == nil {
2891		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2892	}
2893	if v.TargetArns == nil {
2894		invalidParams.Add(smithy.NewErrParamRequired("TargetArns"))
2895	}
2896	if invalidParams.Len() > 0 {
2897		return invalidParams
2898	} else {
2899		return nil
2900	}
2901}
2902
2903func validateOpDeleteApiKeyInput(v *DeleteApiKeyInput) error {
2904	if v == nil {
2905		return nil
2906	}
2907	invalidParams := smithy.InvalidParamsError{Context: "DeleteApiKeyInput"}
2908	if v.ApiKey == nil {
2909		invalidParams.Add(smithy.NewErrParamRequired("ApiKey"))
2910	}
2911	if invalidParams.Len() > 0 {
2912		return invalidParams
2913	} else {
2914		return nil
2915	}
2916}
2917
2918func validateOpDeleteAuthorizerInput(v *DeleteAuthorizerInput) error {
2919	if v == nil {
2920		return nil
2921	}
2922	invalidParams := smithy.InvalidParamsError{Context: "DeleteAuthorizerInput"}
2923	if v.RestApiId == nil {
2924		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
2925	}
2926	if v.AuthorizerId == nil {
2927		invalidParams.Add(smithy.NewErrParamRequired("AuthorizerId"))
2928	}
2929	if invalidParams.Len() > 0 {
2930		return invalidParams
2931	} else {
2932		return nil
2933	}
2934}
2935
2936func validateOpDeleteBasePathMappingInput(v *DeleteBasePathMappingInput) error {
2937	if v == nil {
2938		return nil
2939	}
2940	invalidParams := smithy.InvalidParamsError{Context: "DeleteBasePathMappingInput"}
2941	if v.DomainName == nil {
2942		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
2943	}
2944	if v.BasePath == nil {
2945		invalidParams.Add(smithy.NewErrParamRequired("BasePath"))
2946	}
2947	if invalidParams.Len() > 0 {
2948		return invalidParams
2949	} else {
2950		return nil
2951	}
2952}
2953
2954func validateOpDeleteClientCertificateInput(v *DeleteClientCertificateInput) error {
2955	if v == nil {
2956		return nil
2957	}
2958	invalidParams := smithy.InvalidParamsError{Context: "DeleteClientCertificateInput"}
2959	if v.ClientCertificateId == nil {
2960		invalidParams.Add(smithy.NewErrParamRequired("ClientCertificateId"))
2961	}
2962	if invalidParams.Len() > 0 {
2963		return invalidParams
2964	} else {
2965		return nil
2966	}
2967}
2968
2969func validateOpDeleteDeploymentInput(v *DeleteDeploymentInput) error {
2970	if v == nil {
2971		return nil
2972	}
2973	invalidParams := smithy.InvalidParamsError{Context: "DeleteDeploymentInput"}
2974	if v.RestApiId == nil {
2975		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
2976	}
2977	if v.DeploymentId == nil {
2978		invalidParams.Add(smithy.NewErrParamRequired("DeploymentId"))
2979	}
2980	if invalidParams.Len() > 0 {
2981		return invalidParams
2982	} else {
2983		return nil
2984	}
2985}
2986
2987func validateOpDeleteDocumentationPartInput(v *DeleteDocumentationPartInput) error {
2988	if v == nil {
2989		return nil
2990	}
2991	invalidParams := smithy.InvalidParamsError{Context: "DeleteDocumentationPartInput"}
2992	if v.RestApiId == nil {
2993		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
2994	}
2995	if v.DocumentationPartId == nil {
2996		invalidParams.Add(smithy.NewErrParamRequired("DocumentationPartId"))
2997	}
2998	if invalidParams.Len() > 0 {
2999		return invalidParams
3000	} else {
3001		return nil
3002	}
3003}
3004
3005func validateOpDeleteDocumentationVersionInput(v *DeleteDocumentationVersionInput) error {
3006	if v == nil {
3007		return nil
3008	}
3009	invalidParams := smithy.InvalidParamsError{Context: "DeleteDocumentationVersionInput"}
3010	if v.RestApiId == nil {
3011		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3012	}
3013	if v.DocumentationVersion == nil {
3014		invalidParams.Add(smithy.NewErrParamRequired("DocumentationVersion"))
3015	}
3016	if invalidParams.Len() > 0 {
3017		return invalidParams
3018	} else {
3019		return nil
3020	}
3021}
3022
3023func validateOpDeleteDomainNameInput(v *DeleteDomainNameInput) error {
3024	if v == nil {
3025		return nil
3026	}
3027	invalidParams := smithy.InvalidParamsError{Context: "DeleteDomainNameInput"}
3028	if v.DomainName == nil {
3029		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
3030	}
3031	if invalidParams.Len() > 0 {
3032		return invalidParams
3033	} else {
3034		return nil
3035	}
3036}
3037
3038func validateOpDeleteGatewayResponseInput(v *DeleteGatewayResponseInput) error {
3039	if v == nil {
3040		return nil
3041	}
3042	invalidParams := smithy.InvalidParamsError{Context: "DeleteGatewayResponseInput"}
3043	if v.RestApiId == nil {
3044		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3045	}
3046	if len(v.ResponseType) == 0 {
3047		invalidParams.Add(smithy.NewErrParamRequired("ResponseType"))
3048	}
3049	if invalidParams.Len() > 0 {
3050		return invalidParams
3051	} else {
3052		return nil
3053	}
3054}
3055
3056func validateOpDeleteIntegrationInput(v *DeleteIntegrationInput) error {
3057	if v == nil {
3058		return nil
3059	}
3060	invalidParams := smithy.InvalidParamsError{Context: "DeleteIntegrationInput"}
3061	if v.RestApiId == nil {
3062		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3063	}
3064	if v.ResourceId == nil {
3065		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
3066	}
3067	if v.HttpMethod == nil {
3068		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
3069	}
3070	if invalidParams.Len() > 0 {
3071		return invalidParams
3072	} else {
3073		return nil
3074	}
3075}
3076
3077func validateOpDeleteIntegrationResponseInput(v *DeleteIntegrationResponseInput) error {
3078	if v == nil {
3079		return nil
3080	}
3081	invalidParams := smithy.InvalidParamsError{Context: "DeleteIntegrationResponseInput"}
3082	if v.RestApiId == nil {
3083		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3084	}
3085	if v.ResourceId == nil {
3086		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
3087	}
3088	if v.HttpMethod == nil {
3089		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
3090	}
3091	if v.StatusCode == nil {
3092		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
3093	}
3094	if invalidParams.Len() > 0 {
3095		return invalidParams
3096	} else {
3097		return nil
3098	}
3099}
3100
3101func validateOpDeleteMethodInput(v *DeleteMethodInput) error {
3102	if v == nil {
3103		return nil
3104	}
3105	invalidParams := smithy.InvalidParamsError{Context: "DeleteMethodInput"}
3106	if v.RestApiId == nil {
3107		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3108	}
3109	if v.ResourceId == nil {
3110		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
3111	}
3112	if v.HttpMethod == nil {
3113		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
3114	}
3115	if invalidParams.Len() > 0 {
3116		return invalidParams
3117	} else {
3118		return nil
3119	}
3120}
3121
3122func validateOpDeleteMethodResponseInput(v *DeleteMethodResponseInput) error {
3123	if v == nil {
3124		return nil
3125	}
3126	invalidParams := smithy.InvalidParamsError{Context: "DeleteMethodResponseInput"}
3127	if v.RestApiId == nil {
3128		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3129	}
3130	if v.ResourceId == nil {
3131		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
3132	}
3133	if v.HttpMethod == nil {
3134		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
3135	}
3136	if v.StatusCode == nil {
3137		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
3138	}
3139	if invalidParams.Len() > 0 {
3140		return invalidParams
3141	} else {
3142		return nil
3143	}
3144}
3145
3146func validateOpDeleteModelInput(v *DeleteModelInput) error {
3147	if v == nil {
3148		return nil
3149	}
3150	invalidParams := smithy.InvalidParamsError{Context: "DeleteModelInput"}
3151	if v.RestApiId == nil {
3152		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3153	}
3154	if v.ModelName == nil {
3155		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
3156	}
3157	if invalidParams.Len() > 0 {
3158		return invalidParams
3159	} else {
3160		return nil
3161	}
3162}
3163
3164func validateOpDeleteRequestValidatorInput(v *DeleteRequestValidatorInput) error {
3165	if v == nil {
3166		return nil
3167	}
3168	invalidParams := smithy.InvalidParamsError{Context: "DeleteRequestValidatorInput"}
3169	if v.RestApiId == nil {
3170		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3171	}
3172	if v.RequestValidatorId == nil {
3173		invalidParams.Add(smithy.NewErrParamRequired("RequestValidatorId"))
3174	}
3175	if invalidParams.Len() > 0 {
3176		return invalidParams
3177	} else {
3178		return nil
3179	}
3180}
3181
3182func validateOpDeleteResourceInput(v *DeleteResourceInput) error {
3183	if v == nil {
3184		return nil
3185	}
3186	invalidParams := smithy.InvalidParamsError{Context: "DeleteResourceInput"}
3187	if v.RestApiId == nil {
3188		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3189	}
3190	if v.ResourceId == nil {
3191		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
3192	}
3193	if invalidParams.Len() > 0 {
3194		return invalidParams
3195	} else {
3196		return nil
3197	}
3198}
3199
3200func validateOpDeleteRestApiInput(v *DeleteRestApiInput) error {
3201	if v == nil {
3202		return nil
3203	}
3204	invalidParams := smithy.InvalidParamsError{Context: "DeleteRestApiInput"}
3205	if v.RestApiId == nil {
3206		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3207	}
3208	if invalidParams.Len() > 0 {
3209		return invalidParams
3210	} else {
3211		return nil
3212	}
3213}
3214
3215func validateOpDeleteStageInput(v *DeleteStageInput) error {
3216	if v == nil {
3217		return nil
3218	}
3219	invalidParams := smithy.InvalidParamsError{Context: "DeleteStageInput"}
3220	if v.RestApiId == nil {
3221		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3222	}
3223	if v.StageName == nil {
3224		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
3225	}
3226	if invalidParams.Len() > 0 {
3227		return invalidParams
3228	} else {
3229		return nil
3230	}
3231}
3232
3233func validateOpDeleteUsagePlanInput(v *DeleteUsagePlanInput) error {
3234	if v == nil {
3235		return nil
3236	}
3237	invalidParams := smithy.InvalidParamsError{Context: "DeleteUsagePlanInput"}
3238	if v.UsagePlanId == nil {
3239		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
3240	}
3241	if invalidParams.Len() > 0 {
3242		return invalidParams
3243	} else {
3244		return nil
3245	}
3246}
3247
3248func validateOpDeleteUsagePlanKeyInput(v *DeleteUsagePlanKeyInput) error {
3249	if v == nil {
3250		return nil
3251	}
3252	invalidParams := smithy.InvalidParamsError{Context: "DeleteUsagePlanKeyInput"}
3253	if v.UsagePlanId == nil {
3254		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
3255	}
3256	if v.KeyId == nil {
3257		invalidParams.Add(smithy.NewErrParamRequired("KeyId"))
3258	}
3259	if invalidParams.Len() > 0 {
3260		return invalidParams
3261	} else {
3262		return nil
3263	}
3264}
3265
3266func validateOpDeleteVpcLinkInput(v *DeleteVpcLinkInput) error {
3267	if v == nil {
3268		return nil
3269	}
3270	invalidParams := smithy.InvalidParamsError{Context: "DeleteVpcLinkInput"}
3271	if v.VpcLinkId == nil {
3272		invalidParams.Add(smithy.NewErrParamRequired("VpcLinkId"))
3273	}
3274	if invalidParams.Len() > 0 {
3275		return invalidParams
3276	} else {
3277		return nil
3278	}
3279}
3280
3281func validateOpFlushStageAuthorizersCacheInput(v *FlushStageAuthorizersCacheInput) error {
3282	if v == nil {
3283		return nil
3284	}
3285	invalidParams := smithy.InvalidParamsError{Context: "FlushStageAuthorizersCacheInput"}
3286	if v.RestApiId == nil {
3287		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3288	}
3289	if v.StageName == nil {
3290		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
3291	}
3292	if invalidParams.Len() > 0 {
3293		return invalidParams
3294	} else {
3295		return nil
3296	}
3297}
3298
3299func validateOpFlushStageCacheInput(v *FlushStageCacheInput) error {
3300	if v == nil {
3301		return nil
3302	}
3303	invalidParams := smithy.InvalidParamsError{Context: "FlushStageCacheInput"}
3304	if v.RestApiId == nil {
3305		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3306	}
3307	if v.StageName == nil {
3308		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
3309	}
3310	if invalidParams.Len() > 0 {
3311		return invalidParams
3312	} else {
3313		return nil
3314	}
3315}
3316
3317func validateOpGetApiKeyInput(v *GetApiKeyInput) error {
3318	if v == nil {
3319		return nil
3320	}
3321	invalidParams := smithy.InvalidParamsError{Context: "GetApiKeyInput"}
3322	if v.ApiKey == nil {
3323		invalidParams.Add(smithy.NewErrParamRequired("ApiKey"))
3324	}
3325	if invalidParams.Len() > 0 {
3326		return invalidParams
3327	} else {
3328		return nil
3329	}
3330}
3331
3332func validateOpGetAuthorizerInput(v *GetAuthorizerInput) error {
3333	if v == nil {
3334		return nil
3335	}
3336	invalidParams := smithy.InvalidParamsError{Context: "GetAuthorizerInput"}
3337	if v.RestApiId == nil {
3338		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3339	}
3340	if v.AuthorizerId == nil {
3341		invalidParams.Add(smithy.NewErrParamRequired("AuthorizerId"))
3342	}
3343	if invalidParams.Len() > 0 {
3344		return invalidParams
3345	} else {
3346		return nil
3347	}
3348}
3349
3350func validateOpGetAuthorizersInput(v *GetAuthorizersInput) error {
3351	if v == nil {
3352		return nil
3353	}
3354	invalidParams := smithy.InvalidParamsError{Context: "GetAuthorizersInput"}
3355	if v.RestApiId == nil {
3356		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3357	}
3358	if invalidParams.Len() > 0 {
3359		return invalidParams
3360	} else {
3361		return nil
3362	}
3363}
3364
3365func validateOpGetBasePathMappingInput(v *GetBasePathMappingInput) error {
3366	if v == nil {
3367		return nil
3368	}
3369	invalidParams := smithy.InvalidParamsError{Context: "GetBasePathMappingInput"}
3370	if v.DomainName == nil {
3371		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
3372	}
3373	if v.BasePath == nil {
3374		invalidParams.Add(smithy.NewErrParamRequired("BasePath"))
3375	}
3376	if invalidParams.Len() > 0 {
3377		return invalidParams
3378	} else {
3379		return nil
3380	}
3381}
3382
3383func validateOpGetBasePathMappingsInput(v *GetBasePathMappingsInput) error {
3384	if v == nil {
3385		return nil
3386	}
3387	invalidParams := smithy.InvalidParamsError{Context: "GetBasePathMappingsInput"}
3388	if v.DomainName == nil {
3389		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
3390	}
3391	if invalidParams.Len() > 0 {
3392		return invalidParams
3393	} else {
3394		return nil
3395	}
3396}
3397
3398func validateOpGetClientCertificateInput(v *GetClientCertificateInput) error {
3399	if v == nil {
3400		return nil
3401	}
3402	invalidParams := smithy.InvalidParamsError{Context: "GetClientCertificateInput"}
3403	if v.ClientCertificateId == nil {
3404		invalidParams.Add(smithy.NewErrParamRequired("ClientCertificateId"))
3405	}
3406	if invalidParams.Len() > 0 {
3407		return invalidParams
3408	} else {
3409		return nil
3410	}
3411}
3412
3413func validateOpGetDeploymentInput(v *GetDeploymentInput) error {
3414	if v == nil {
3415		return nil
3416	}
3417	invalidParams := smithy.InvalidParamsError{Context: "GetDeploymentInput"}
3418	if v.RestApiId == nil {
3419		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3420	}
3421	if v.DeploymentId == nil {
3422		invalidParams.Add(smithy.NewErrParamRequired("DeploymentId"))
3423	}
3424	if invalidParams.Len() > 0 {
3425		return invalidParams
3426	} else {
3427		return nil
3428	}
3429}
3430
3431func validateOpGetDeploymentsInput(v *GetDeploymentsInput) error {
3432	if v == nil {
3433		return nil
3434	}
3435	invalidParams := smithy.InvalidParamsError{Context: "GetDeploymentsInput"}
3436	if v.RestApiId == nil {
3437		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3438	}
3439	if invalidParams.Len() > 0 {
3440		return invalidParams
3441	} else {
3442		return nil
3443	}
3444}
3445
3446func validateOpGetDocumentationPartInput(v *GetDocumentationPartInput) error {
3447	if v == nil {
3448		return nil
3449	}
3450	invalidParams := smithy.InvalidParamsError{Context: "GetDocumentationPartInput"}
3451	if v.RestApiId == nil {
3452		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3453	}
3454	if v.DocumentationPartId == nil {
3455		invalidParams.Add(smithy.NewErrParamRequired("DocumentationPartId"))
3456	}
3457	if invalidParams.Len() > 0 {
3458		return invalidParams
3459	} else {
3460		return nil
3461	}
3462}
3463
3464func validateOpGetDocumentationPartsInput(v *GetDocumentationPartsInput) error {
3465	if v == nil {
3466		return nil
3467	}
3468	invalidParams := smithy.InvalidParamsError{Context: "GetDocumentationPartsInput"}
3469	if v.RestApiId == nil {
3470		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3471	}
3472	if invalidParams.Len() > 0 {
3473		return invalidParams
3474	} else {
3475		return nil
3476	}
3477}
3478
3479func validateOpGetDocumentationVersionInput(v *GetDocumentationVersionInput) error {
3480	if v == nil {
3481		return nil
3482	}
3483	invalidParams := smithy.InvalidParamsError{Context: "GetDocumentationVersionInput"}
3484	if v.RestApiId == nil {
3485		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3486	}
3487	if v.DocumentationVersion == nil {
3488		invalidParams.Add(smithy.NewErrParamRequired("DocumentationVersion"))
3489	}
3490	if invalidParams.Len() > 0 {
3491		return invalidParams
3492	} else {
3493		return nil
3494	}
3495}
3496
3497func validateOpGetDocumentationVersionsInput(v *GetDocumentationVersionsInput) error {
3498	if v == nil {
3499		return nil
3500	}
3501	invalidParams := smithy.InvalidParamsError{Context: "GetDocumentationVersionsInput"}
3502	if v.RestApiId == nil {
3503		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3504	}
3505	if invalidParams.Len() > 0 {
3506		return invalidParams
3507	} else {
3508		return nil
3509	}
3510}
3511
3512func validateOpGetDomainNameInput(v *GetDomainNameInput) error {
3513	if v == nil {
3514		return nil
3515	}
3516	invalidParams := smithy.InvalidParamsError{Context: "GetDomainNameInput"}
3517	if v.DomainName == nil {
3518		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
3519	}
3520	if invalidParams.Len() > 0 {
3521		return invalidParams
3522	} else {
3523		return nil
3524	}
3525}
3526
3527func validateOpGetExportInput(v *GetExportInput) error {
3528	if v == nil {
3529		return nil
3530	}
3531	invalidParams := smithy.InvalidParamsError{Context: "GetExportInput"}
3532	if v.RestApiId == nil {
3533		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3534	}
3535	if v.StageName == nil {
3536		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
3537	}
3538	if v.ExportType == nil {
3539		invalidParams.Add(smithy.NewErrParamRequired("ExportType"))
3540	}
3541	if invalidParams.Len() > 0 {
3542		return invalidParams
3543	} else {
3544		return nil
3545	}
3546}
3547
3548func validateOpGetGatewayResponseInput(v *GetGatewayResponseInput) error {
3549	if v == nil {
3550		return nil
3551	}
3552	invalidParams := smithy.InvalidParamsError{Context: "GetGatewayResponseInput"}
3553	if v.RestApiId == nil {
3554		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3555	}
3556	if len(v.ResponseType) == 0 {
3557		invalidParams.Add(smithy.NewErrParamRequired("ResponseType"))
3558	}
3559	if invalidParams.Len() > 0 {
3560		return invalidParams
3561	} else {
3562		return nil
3563	}
3564}
3565
3566func validateOpGetGatewayResponsesInput(v *GetGatewayResponsesInput) error {
3567	if v == nil {
3568		return nil
3569	}
3570	invalidParams := smithy.InvalidParamsError{Context: "GetGatewayResponsesInput"}
3571	if v.RestApiId == nil {
3572		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3573	}
3574	if invalidParams.Len() > 0 {
3575		return invalidParams
3576	} else {
3577		return nil
3578	}
3579}
3580
3581func validateOpGetIntegrationInput(v *GetIntegrationInput) error {
3582	if v == nil {
3583		return nil
3584	}
3585	invalidParams := smithy.InvalidParamsError{Context: "GetIntegrationInput"}
3586	if v.RestApiId == nil {
3587		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3588	}
3589	if v.ResourceId == nil {
3590		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
3591	}
3592	if v.HttpMethod == nil {
3593		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
3594	}
3595	if invalidParams.Len() > 0 {
3596		return invalidParams
3597	} else {
3598		return nil
3599	}
3600}
3601
3602func validateOpGetIntegrationResponseInput(v *GetIntegrationResponseInput) error {
3603	if v == nil {
3604		return nil
3605	}
3606	invalidParams := smithy.InvalidParamsError{Context: "GetIntegrationResponseInput"}
3607	if v.RestApiId == nil {
3608		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3609	}
3610	if v.ResourceId == nil {
3611		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
3612	}
3613	if v.HttpMethod == nil {
3614		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
3615	}
3616	if v.StatusCode == nil {
3617		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
3618	}
3619	if invalidParams.Len() > 0 {
3620		return invalidParams
3621	} else {
3622		return nil
3623	}
3624}
3625
3626func validateOpGetMethodInput(v *GetMethodInput) error {
3627	if v == nil {
3628		return nil
3629	}
3630	invalidParams := smithy.InvalidParamsError{Context: "GetMethodInput"}
3631	if v.RestApiId == nil {
3632		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3633	}
3634	if v.ResourceId == nil {
3635		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
3636	}
3637	if v.HttpMethod == nil {
3638		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
3639	}
3640	if invalidParams.Len() > 0 {
3641		return invalidParams
3642	} else {
3643		return nil
3644	}
3645}
3646
3647func validateOpGetMethodResponseInput(v *GetMethodResponseInput) error {
3648	if v == nil {
3649		return nil
3650	}
3651	invalidParams := smithy.InvalidParamsError{Context: "GetMethodResponseInput"}
3652	if v.RestApiId == nil {
3653		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3654	}
3655	if v.ResourceId == nil {
3656		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
3657	}
3658	if v.HttpMethod == nil {
3659		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
3660	}
3661	if v.StatusCode == nil {
3662		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
3663	}
3664	if invalidParams.Len() > 0 {
3665		return invalidParams
3666	} else {
3667		return nil
3668	}
3669}
3670
3671func validateOpGetModelInput(v *GetModelInput) error {
3672	if v == nil {
3673		return nil
3674	}
3675	invalidParams := smithy.InvalidParamsError{Context: "GetModelInput"}
3676	if v.RestApiId == nil {
3677		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3678	}
3679	if v.ModelName == nil {
3680		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
3681	}
3682	if invalidParams.Len() > 0 {
3683		return invalidParams
3684	} else {
3685		return nil
3686	}
3687}
3688
3689func validateOpGetModelsInput(v *GetModelsInput) error {
3690	if v == nil {
3691		return nil
3692	}
3693	invalidParams := smithy.InvalidParamsError{Context: "GetModelsInput"}
3694	if v.RestApiId == nil {
3695		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3696	}
3697	if invalidParams.Len() > 0 {
3698		return invalidParams
3699	} else {
3700		return nil
3701	}
3702}
3703
3704func validateOpGetModelTemplateInput(v *GetModelTemplateInput) error {
3705	if v == nil {
3706		return nil
3707	}
3708	invalidParams := smithy.InvalidParamsError{Context: "GetModelTemplateInput"}
3709	if v.RestApiId == nil {
3710		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3711	}
3712	if v.ModelName == nil {
3713		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
3714	}
3715	if invalidParams.Len() > 0 {
3716		return invalidParams
3717	} else {
3718		return nil
3719	}
3720}
3721
3722func validateOpGetRequestValidatorInput(v *GetRequestValidatorInput) error {
3723	if v == nil {
3724		return nil
3725	}
3726	invalidParams := smithy.InvalidParamsError{Context: "GetRequestValidatorInput"}
3727	if v.RestApiId == nil {
3728		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3729	}
3730	if v.RequestValidatorId == nil {
3731		invalidParams.Add(smithy.NewErrParamRequired("RequestValidatorId"))
3732	}
3733	if invalidParams.Len() > 0 {
3734		return invalidParams
3735	} else {
3736		return nil
3737	}
3738}
3739
3740func validateOpGetRequestValidatorsInput(v *GetRequestValidatorsInput) error {
3741	if v == nil {
3742		return nil
3743	}
3744	invalidParams := smithy.InvalidParamsError{Context: "GetRequestValidatorsInput"}
3745	if v.RestApiId == nil {
3746		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3747	}
3748	if invalidParams.Len() > 0 {
3749		return invalidParams
3750	} else {
3751		return nil
3752	}
3753}
3754
3755func validateOpGetResourceInput(v *GetResourceInput) error {
3756	if v == nil {
3757		return nil
3758	}
3759	invalidParams := smithy.InvalidParamsError{Context: "GetResourceInput"}
3760	if v.RestApiId == nil {
3761		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3762	}
3763	if v.ResourceId == nil {
3764		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
3765	}
3766	if invalidParams.Len() > 0 {
3767		return invalidParams
3768	} else {
3769		return nil
3770	}
3771}
3772
3773func validateOpGetResourcesInput(v *GetResourcesInput) error {
3774	if v == nil {
3775		return nil
3776	}
3777	invalidParams := smithy.InvalidParamsError{Context: "GetResourcesInput"}
3778	if v.RestApiId == nil {
3779		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3780	}
3781	if invalidParams.Len() > 0 {
3782		return invalidParams
3783	} else {
3784		return nil
3785	}
3786}
3787
3788func validateOpGetRestApiInput(v *GetRestApiInput) error {
3789	if v == nil {
3790		return nil
3791	}
3792	invalidParams := smithy.InvalidParamsError{Context: "GetRestApiInput"}
3793	if v.RestApiId == nil {
3794		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3795	}
3796	if invalidParams.Len() > 0 {
3797		return invalidParams
3798	} else {
3799		return nil
3800	}
3801}
3802
3803func validateOpGetSdkInput(v *GetSdkInput) error {
3804	if v == nil {
3805		return nil
3806	}
3807	invalidParams := smithy.InvalidParamsError{Context: "GetSdkInput"}
3808	if v.RestApiId == nil {
3809		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3810	}
3811	if v.StageName == nil {
3812		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
3813	}
3814	if v.SdkType == nil {
3815		invalidParams.Add(smithy.NewErrParamRequired("SdkType"))
3816	}
3817	if invalidParams.Len() > 0 {
3818		return invalidParams
3819	} else {
3820		return nil
3821	}
3822}
3823
3824func validateOpGetSdkTypeInput(v *GetSdkTypeInput) error {
3825	if v == nil {
3826		return nil
3827	}
3828	invalidParams := smithy.InvalidParamsError{Context: "GetSdkTypeInput"}
3829	if v.Id == nil {
3830		invalidParams.Add(smithy.NewErrParamRequired("Id"))
3831	}
3832	if invalidParams.Len() > 0 {
3833		return invalidParams
3834	} else {
3835		return nil
3836	}
3837}
3838
3839func validateOpGetStageInput(v *GetStageInput) error {
3840	if v == nil {
3841		return nil
3842	}
3843	invalidParams := smithy.InvalidParamsError{Context: "GetStageInput"}
3844	if v.RestApiId == nil {
3845		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3846	}
3847	if v.StageName == nil {
3848		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
3849	}
3850	if invalidParams.Len() > 0 {
3851		return invalidParams
3852	} else {
3853		return nil
3854	}
3855}
3856
3857func validateOpGetStagesInput(v *GetStagesInput) error {
3858	if v == nil {
3859		return nil
3860	}
3861	invalidParams := smithy.InvalidParamsError{Context: "GetStagesInput"}
3862	if v.RestApiId == nil {
3863		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3864	}
3865	if invalidParams.Len() > 0 {
3866		return invalidParams
3867	} else {
3868		return nil
3869	}
3870}
3871
3872func validateOpGetTagsInput(v *GetTagsInput) error {
3873	if v == nil {
3874		return nil
3875	}
3876	invalidParams := smithy.InvalidParamsError{Context: "GetTagsInput"}
3877	if v.ResourceArn == nil {
3878		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
3879	}
3880	if invalidParams.Len() > 0 {
3881		return invalidParams
3882	} else {
3883		return nil
3884	}
3885}
3886
3887func validateOpGetUsageInput(v *GetUsageInput) error {
3888	if v == nil {
3889		return nil
3890	}
3891	invalidParams := smithy.InvalidParamsError{Context: "GetUsageInput"}
3892	if v.UsagePlanId == nil {
3893		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
3894	}
3895	if v.StartDate == nil {
3896		invalidParams.Add(smithy.NewErrParamRequired("StartDate"))
3897	}
3898	if v.EndDate == nil {
3899		invalidParams.Add(smithy.NewErrParamRequired("EndDate"))
3900	}
3901	if invalidParams.Len() > 0 {
3902		return invalidParams
3903	} else {
3904		return nil
3905	}
3906}
3907
3908func validateOpGetUsagePlanInput(v *GetUsagePlanInput) error {
3909	if v == nil {
3910		return nil
3911	}
3912	invalidParams := smithy.InvalidParamsError{Context: "GetUsagePlanInput"}
3913	if v.UsagePlanId == nil {
3914		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
3915	}
3916	if invalidParams.Len() > 0 {
3917		return invalidParams
3918	} else {
3919		return nil
3920	}
3921}
3922
3923func validateOpGetUsagePlanKeyInput(v *GetUsagePlanKeyInput) error {
3924	if v == nil {
3925		return nil
3926	}
3927	invalidParams := smithy.InvalidParamsError{Context: "GetUsagePlanKeyInput"}
3928	if v.UsagePlanId == nil {
3929		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
3930	}
3931	if v.KeyId == nil {
3932		invalidParams.Add(smithy.NewErrParamRequired("KeyId"))
3933	}
3934	if invalidParams.Len() > 0 {
3935		return invalidParams
3936	} else {
3937		return nil
3938	}
3939}
3940
3941func validateOpGetUsagePlanKeysInput(v *GetUsagePlanKeysInput) error {
3942	if v == nil {
3943		return nil
3944	}
3945	invalidParams := smithy.InvalidParamsError{Context: "GetUsagePlanKeysInput"}
3946	if v.UsagePlanId == nil {
3947		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
3948	}
3949	if invalidParams.Len() > 0 {
3950		return invalidParams
3951	} else {
3952		return nil
3953	}
3954}
3955
3956func validateOpGetVpcLinkInput(v *GetVpcLinkInput) error {
3957	if v == nil {
3958		return nil
3959	}
3960	invalidParams := smithy.InvalidParamsError{Context: "GetVpcLinkInput"}
3961	if v.VpcLinkId == nil {
3962		invalidParams.Add(smithy.NewErrParamRequired("VpcLinkId"))
3963	}
3964	if invalidParams.Len() > 0 {
3965		return invalidParams
3966	} else {
3967		return nil
3968	}
3969}
3970
3971func validateOpImportApiKeysInput(v *ImportApiKeysInput) error {
3972	if v == nil {
3973		return nil
3974	}
3975	invalidParams := smithy.InvalidParamsError{Context: "ImportApiKeysInput"}
3976	if v.Body == nil {
3977		invalidParams.Add(smithy.NewErrParamRequired("Body"))
3978	}
3979	if len(v.Format) == 0 {
3980		invalidParams.Add(smithy.NewErrParamRequired("Format"))
3981	}
3982	if invalidParams.Len() > 0 {
3983		return invalidParams
3984	} else {
3985		return nil
3986	}
3987}
3988
3989func validateOpImportDocumentationPartsInput(v *ImportDocumentationPartsInput) error {
3990	if v == nil {
3991		return nil
3992	}
3993	invalidParams := smithy.InvalidParamsError{Context: "ImportDocumentationPartsInput"}
3994	if v.RestApiId == nil {
3995		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
3996	}
3997	if v.Body == nil {
3998		invalidParams.Add(smithy.NewErrParamRequired("Body"))
3999	}
4000	if invalidParams.Len() > 0 {
4001		return invalidParams
4002	} else {
4003		return nil
4004	}
4005}
4006
4007func validateOpImportRestApiInput(v *ImportRestApiInput) error {
4008	if v == nil {
4009		return nil
4010	}
4011	invalidParams := smithy.InvalidParamsError{Context: "ImportRestApiInput"}
4012	if v.Body == nil {
4013		invalidParams.Add(smithy.NewErrParamRequired("Body"))
4014	}
4015	if invalidParams.Len() > 0 {
4016		return invalidParams
4017	} else {
4018		return nil
4019	}
4020}
4021
4022func validateOpPutGatewayResponseInput(v *PutGatewayResponseInput) error {
4023	if v == nil {
4024		return nil
4025	}
4026	invalidParams := smithy.InvalidParamsError{Context: "PutGatewayResponseInput"}
4027	if v.RestApiId == nil {
4028		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4029	}
4030	if len(v.ResponseType) == 0 {
4031		invalidParams.Add(smithy.NewErrParamRequired("ResponseType"))
4032	}
4033	if invalidParams.Len() > 0 {
4034		return invalidParams
4035	} else {
4036		return nil
4037	}
4038}
4039
4040func validateOpPutIntegrationInput(v *PutIntegrationInput) error {
4041	if v == nil {
4042		return nil
4043	}
4044	invalidParams := smithy.InvalidParamsError{Context: "PutIntegrationInput"}
4045	if v.RestApiId == nil {
4046		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4047	}
4048	if v.ResourceId == nil {
4049		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
4050	}
4051	if v.HttpMethod == nil {
4052		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
4053	}
4054	if len(v.Type) == 0 {
4055		invalidParams.Add(smithy.NewErrParamRequired("Type"))
4056	}
4057	if invalidParams.Len() > 0 {
4058		return invalidParams
4059	} else {
4060		return nil
4061	}
4062}
4063
4064func validateOpPutIntegrationResponseInput(v *PutIntegrationResponseInput) error {
4065	if v == nil {
4066		return nil
4067	}
4068	invalidParams := smithy.InvalidParamsError{Context: "PutIntegrationResponseInput"}
4069	if v.RestApiId == nil {
4070		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4071	}
4072	if v.ResourceId == nil {
4073		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
4074	}
4075	if v.HttpMethod == nil {
4076		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
4077	}
4078	if v.StatusCode == nil {
4079		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
4080	}
4081	if invalidParams.Len() > 0 {
4082		return invalidParams
4083	} else {
4084		return nil
4085	}
4086}
4087
4088func validateOpPutMethodInput(v *PutMethodInput) error {
4089	if v == nil {
4090		return nil
4091	}
4092	invalidParams := smithy.InvalidParamsError{Context: "PutMethodInput"}
4093	if v.RestApiId == nil {
4094		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4095	}
4096	if v.ResourceId == nil {
4097		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
4098	}
4099	if v.HttpMethod == nil {
4100		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
4101	}
4102	if v.AuthorizationType == nil {
4103		invalidParams.Add(smithy.NewErrParamRequired("AuthorizationType"))
4104	}
4105	if invalidParams.Len() > 0 {
4106		return invalidParams
4107	} else {
4108		return nil
4109	}
4110}
4111
4112func validateOpPutMethodResponseInput(v *PutMethodResponseInput) error {
4113	if v == nil {
4114		return nil
4115	}
4116	invalidParams := smithy.InvalidParamsError{Context: "PutMethodResponseInput"}
4117	if v.RestApiId == nil {
4118		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4119	}
4120	if v.ResourceId == nil {
4121		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
4122	}
4123	if v.HttpMethod == nil {
4124		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
4125	}
4126	if v.StatusCode == nil {
4127		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
4128	}
4129	if invalidParams.Len() > 0 {
4130		return invalidParams
4131	} else {
4132		return nil
4133	}
4134}
4135
4136func validateOpPutRestApiInput(v *PutRestApiInput) error {
4137	if v == nil {
4138		return nil
4139	}
4140	invalidParams := smithy.InvalidParamsError{Context: "PutRestApiInput"}
4141	if v.RestApiId == nil {
4142		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4143	}
4144	if v.Body == nil {
4145		invalidParams.Add(smithy.NewErrParamRequired("Body"))
4146	}
4147	if invalidParams.Len() > 0 {
4148		return invalidParams
4149	} else {
4150		return nil
4151	}
4152}
4153
4154func validateOpTagResourceInput(v *TagResourceInput) error {
4155	if v == nil {
4156		return nil
4157	}
4158	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
4159	if v.ResourceArn == nil {
4160		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
4161	}
4162	if v.Tags == nil {
4163		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
4164	}
4165	if invalidParams.Len() > 0 {
4166		return invalidParams
4167	} else {
4168		return nil
4169	}
4170}
4171
4172func validateOpTestInvokeAuthorizerInput(v *TestInvokeAuthorizerInput) error {
4173	if v == nil {
4174		return nil
4175	}
4176	invalidParams := smithy.InvalidParamsError{Context: "TestInvokeAuthorizerInput"}
4177	if v.RestApiId == nil {
4178		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4179	}
4180	if v.AuthorizerId == nil {
4181		invalidParams.Add(smithy.NewErrParamRequired("AuthorizerId"))
4182	}
4183	if invalidParams.Len() > 0 {
4184		return invalidParams
4185	} else {
4186		return nil
4187	}
4188}
4189
4190func validateOpTestInvokeMethodInput(v *TestInvokeMethodInput) error {
4191	if v == nil {
4192		return nil
4193	}
4194	invalidParams := smithy.InvalidParamsError{Context: "TestInvokeMethodInput"}
4195	if v.RestApiId == nil {
4196		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4197	}
4198	if v.ResourceId == nil {
4199		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
4200	}
4201	if v.HttpMethod == nil {
4202		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
4203	}
4204	if invalidParams.Len() > 0 {
4205		return invalidParams
4206	} else {
4207		return nil
4208	}
4209}
4210
4211func validateOpUntagResourceInput(v *UntagResourceInput) error {
4212	if v == nil {
4213		return nil
4214	}
4215	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
4216	if v.ResourceArn == nil {
4217		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
4218	}
4219	if v.TagKeys == nil {
4220		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
4221	}
4222	if invalidParams.Len() > 0 {
4223		return invalidParams
4224	} else {
4225		return nil
4226	}
4227}
4228
4229func validateOpUpdateApiKeyInput(v *UpdateApiKeyInput) error {
4230	if v == nil {
4231		return nil
4232	}
4233	invalidParams := smithy.InvalidParamsError{Context: "UpdateApiKeyInput"}
4234	if v.ApiKey == nil {
4235		invalidParams.Add(smithy.NewErrParamRequired("ApiKey"))
4236	}
4237	if invalidParams.Len() > 0 {
4238		return invalidParams
4239	} else {
4240		return nil
4241	}
4242}
4243
4244func validateOpUpdateAuthorizerInput(v *UpdateAuthorizerInput) error {
4245	if v == nil {
4246		return nil
4247	}
4248	invalidParams := smithy.InvalidParamsError{Context: "UpdateAuthorizerInput"}
4249	if v.RestApiId == nil {
4250		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4251	}
4252	if v.AuthorizerId == nil {
4253		invalidParams.Add(smithy.NewErrParamRequired("AuthorizerId"))
4254	}
4255	if invalidParams.Len() > 0 {
4256		return invalidParams
4257	} else {
4258		return nil
4259	}
4260}
4261
4262func validateOpUpdateBasePathMappingInput(v *UpdateBasePathMappingInput) error {
4263	if v == nil {
4264		return nil
4265	}
4266	invalidParams := smithy.InvalidParamsError{Context: "UpdateBasePathMappingInput"}
4267	if v.DomainName == nil {
4268		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
4269	}
4270	if v.BasePath == nil {
4271		invalidParams.Add(smithy.NewErrParamRequired("BasePath"))
4272	}
4273	if invalidParams.Len() > 0 {
4274		return invalidParams
4275	} else {
4276		return nil
4277	}
4278}
4279
4280func validateOpUpdateClientCertificateInput(v *UpdateClientCertificateInput) error {
4281	if v == nil {
4282		return nil
4283	}
4284	invalidParams := smithy.InvalidParamsError{Context: "UpdateClientCertificateInput"}
4285	if v.ClientCertificateId == nil {
4286		invalidParams.Add(smithy.NewErrParamRequired("ClientCertificateId"))
4287	}
4288	if invalidParams.Len() > 0 {
4289		return invalidParams
4290	} else {
4291		return nil
4292	}
4293}
4294
4295func validateOpUpdateDeploymentInput(v *UpdateDeploymentInput) error {
4296	if v == nil {
4297		return nil
4298	}
4299	invalidParams := smithy.InvalidParamsError{Context: "UpdateDeploymentInput"}
4300	if v.RestApiId == nil {
4301		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4302	}
4303	if v.DeploymentId == nil {
4304		invalidParams.Add(smithy.NewErrParamRequired("DeploymentId"))
4305	}
4306	if invalidParams.Len() > 0 {
4307		return invalidParams
4308	} else {
4309		return nil
4310	}
4311}
4312
4313func validateOpUpdateDocumentationPartInput(v *UpdateDocumentationPartInput) error {
4314	if v == nil {
4315		return nil
4316	}
4317	invalidParams := smithy.InvalidParamsError{Context: "UpdateDocumentationPartInput"}
4318	if v.RestApiId == nil {
4319		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4320	}
4321	if v.DocumentationPartId == nil {
4322		invalidParams.Add(smithy.NewErrParamRequired("DocumentationPartId"))
4323	}
4324	if invalidParams.Len() > 0 {
4325		return invalidParams
4326	} else {
4327		return nil
4328	}
4329}
4330
4331func validateOpUpdateDocumentationVersionInput(v *UpdateDocumentationVersionInput) error {
4332	if v == nil {
4333		return nil
4334	}
4335	invalidParams := smithy.InvalidParamsError{Context: "UpdateDocumentationVersionInput"}
4336	if v.RestApiId == nil {
4337		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4338	}
4339	if v.DocumentationVersion == nil {
4340		invalidParams.Add(smithy.NewErrParamRequired("DocumentationVersion"))
4341	}
4342	if invalidParams.Len() > 0 {
4343		return invalidParams
4344	} else {
4345		return nil
4346	}
4347}
4348
4349func validateOpUpdateDomainNameInput(v *UpdateDomainNameInput) error {
4350	if v == nil {
4351		return nil
4352	}
4353	invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainNameInput"}
4354	if v.DomainName == nil {
4355		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
4356	}
4357	if invalidParams.Len() > 0 {
4358		return invalidParams
4359	} else {
4360		return nil
4361	}
4362}
4363
4364func validateOpUpdateGatewayResponseInput(v *UpdateGatewayResponseInput) error {
4365	if v == nil {
4366		return nil
4367	}
4368	invalidParams := smithy.InvalidParamsError{Context: "UpdateGatewayResponseInput"}
4369	if v.RestApiId == nil {
4370		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4371	}
4372	if len(v.ResponseType) == 0 {
4373		invalidParams.Add(smithy.NewErrParamRequired("ResponseType"))
4374	}
4375	if invalidParams.Len() > 0 {
4376		return invalidParams
4377	} else {
4378		return nil
4379	}
4380}
4381
4382func validateOpUpdateIntegrationInput(v *UpdateIntegrationInput) error {
4383	if v == nil {
4384		return nil
4385	}
4386	invalidParams := smithy.InvalidParamsError{Context: "UpdateIntegrationInput"}
4387	if v.RestApiId == nil {
4388		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4389	}
4390	if v.ResourceId == nil {
4391		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
4392	}
4393	if v.HttpMethod == nil {
4394		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
4395	}
4396	if invalidParams.Len() > 0 {
4397		return invalidParams
4398	} else {
4399		return nil
4400	}
4401}
4402
4403func validateOpUpdateIntegrationResponseInput(v *UpdateIntegrationResponseInput) error {
4404	if v == nil {
4405		return nil
4406	}
4407	invalidParams := smithy.InvalidParamsError{Context: "UpdateIntegrationResponseInput"}
4408	if v.RestApiId == nil {
4409		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4410	}
4411	if v.ResourceId == nil {
4412		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
4413	}
4414	if v.HttpMethod == nil {
4415		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
4416	}
4417	if v.StatusCode == nil {
4418		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
4419	}
4420	if invalidParams.Len() > 0 {
4421		return invalidParams
4422	} else {
4423		return nil
4424	}
4425}
4426
4427func validateOpUpdateMethodInput(v *UpdateMethodInput) error {
4428	if v == nil {
4429		return nil
4430	}
4431	invalidParams := smithy.InvalidParamsError{Context: "UpdateMethodInput"}
4432	if v.RestApiId == nil {
4433		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4434	}
4435	if v.ResourceId == nil {
4436		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
4437	}
4438	if v.HttpMethod == nil {
4439		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
4440	}
4441	if invalidParams.Len() > 0 {
4442		return invalidParams
4443	} else {
4444		return nil
4445	}
4446}
4447
4448func validateOpUpdateMethodResponseInput(v *UpdateMethodResponseInput) error {
4449	if v == nil {
4450		return nil
4451	}
4452	invalidParams := smithy.InvalidParamsError{Context: "UpdateMethodResponseInput"}
4453	if v.RestApiId == nil {
4454		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4455	}
4456	if v.ResourceId == nil {
4457		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
4458	}
4459	if v.HttpMethod == nil {
4460		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
4461	}
4462	if v.StatusCode == nil {
4463		invalidParams.Add(smithy.NewErrParamRequired("StatusCode"))
4464	}
4465	if invalidParams.Len() > 0 {
4466		return invalidParams
4467	} else {
4468		return nil
4469	}
4470}
4471
4472func validateOpUpdateModelInput(v *UpdateModelInput) error {
4473	if v == nil {
4474		return nil
4475	}
4476	invalidParams := smithy.InvalidParamsError{Context: "UpdateModelInput"}
4477	if v.RestApiId == nil {
4478		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4479	}
4480	if v.ModelName == nil {
4481		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
4482	}
4483	if invalidParams.Len() > 0 {
4484		return invalidParams
4485	} else {
4486		return nil
4487	}
4488}
4489
4490func validateOpUpdateRequestValidatorInput(v *UpdateRequestValidatorInput) error {
4491	if v == nil {
4492		return nil
4493	}
4494	invalidParams := smithy.InvalidParamsError{Context: "UpdateRequestValidatorInput"}
4495	if v.RestApiId == nil {
4496		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4497	}
4498	if v.RequestValidatorId == nil {
4499		invalidParams.Add(smithy.NewErrParamRequired("RequestValidatorId"))
4500	}
4501	if invalidParams.Len() > 0 {
4502		return invalidParams
4503	} else {
4504		return nil
4505	}
4506}
4507
4508func validateOpUpdateResourceInput(v *UpdateResourceInput) error {
4509	if v == nil {
4510		return nil
4511	}
4512	invalidParams := smithy.InvalidParamsError{Context: "UpdateResourceInput"}
4513	if v.RestApiId == nil {
4514		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4515	}
4516	if v.ResourceId == nil {
4517		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
4518	}
4519	if invalidParams.Len() > 0 {
4520		return invalidParams
4521	} else {
4522		return nil
4523	}
4524}
4525
4526func validateOpUpdateRestApiInput(v *UpdateRestApiInput) error {
4527	if v == nil {
4528		return nil
4529	}
4530	invalidParams := smithy.InvalidParamsError{Context: "UpdateRestApiInput"}
4531	if v.RestApiId == nil {
4532		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4533	}
4534	if invalidParams.Len() > 0 {
4535		return invalidParams
4536	} else {
4537		return nil
4538	}
4539}
4540
4541func validateOpUpdateStageInput(v *UpdateStageInput) error {
4542	if v == nil {
4543		return nil
4544	}
4545	invalidParams := smithy.InvalidParamsError{Context: "UpdateStageInput"}
4546	if v.RestApiId == nil {
4547		invalidParams.Add(smithy.NewErrParamRequired("RestApiId"))
4548	}
4549	if v.StageName == nil {
4550		invalidParams.Add(smithy.NewErrParamRequired("StageName"))
4551	}
4552	if invalidParams.Len() > 0 {
4553		return invalidParams
4554	} else {
4555		return nil
4556	}
4557}
4558
4559func validateOpUpdateUsageInput(v *UpdateUsageInput) error {
4560	if v == nil {
4561		return nil
4562	}
4563	invalidParams := smithy.InvalidParamsError{Context: "UpdateUsageInput"}
4564	if v.UsagePlanId == nil {
4565		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
4566	}
4567	if v.KeyId == nil {
4568		invalidParams.Add(smithy.NewErrParamRequired("KeyId"))
4569	}
4570	if invalidParams.Len() > 0 {
4571		return invalidParams
4572	} else {
4573		return nil
4574	}
4575}
4576
4577func validateOpUpdateUsagePlanInput(v *UpdateUsagePlanInput) error {
4578	if v == nil {
4579		return nil
4580	}
4581	invalidParams := smithy.InvalidParamsError{Context: "UpdateUsagePlanInput"}
4582	if v.UsagePlanId == nil {
4583		invalidParams.Add(smithy.NewErrParamRequired("UsagePlanId"))
4584	}
4585	if invalidParams.Len() > 0 {
4586		return invalidParams
4587	} else {
4588		return nil
4589	}
4590}
4591
4592func validateOpUpdateVpcLinkInput(v *UpdateVpcLinkInput) error {
4593	if v == nil {
4594		return nil
4595	}
4596	invalidParams := smithy.InvalidParamsError{Context: "UpdateVpcLinkInput"}
4597	if v.VpcLinkId == nil {
4598		invalidParams.Add(smithy.NewErrParamRequired("VpcLinkId"))
4599	}
4600	if invalidParams.Len() > 0 {
4601		return invalidParams
4602	} else {
4603		return nil
4604	}
4605}
4606