1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package appmesh
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/appmesh/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpCreateGatewayRoute struct {
14}
15
16func (*validateOpCreateGatewayRoute) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpCreateGatewayRoute) 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.(*CreateGatewayRouteInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpCreateGatewayRouteInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCreateMesh struct {
34}
35
36func (*validateOpCreateMesh) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCreateMesh) 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.(*CreateMeshInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCreateMeshInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateRoute struct {
54}
55
56func (*validateOpCreateRoute) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateRoute) 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.(*CreateRouteInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateRouteInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateVirtualGateway struct {
74}
75
76func (*validateOpCreateVirtualGateway) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateVirtualGateway) 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.(*CreateVirtualGatewayInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateVirtualGatewayInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateVirtualNode struct {
94}
95
96func (*validateOpCreateVirtualNode) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateVirtualNode) 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.(*CreateVirtualNodeInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateVirtualNodeInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateVirtualRouter struct {
114}
115
116func (*validateOpCreateVirtualRouter) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateVirtualRouter) 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.(*CreateVirtualRouterInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateVirtualRouterInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpCreateVirtualService struct {
134}
135
136func (*validateOpCreateVirtualService) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpCreateVirtualService) 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.(*CreateVirtualServiceInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpCreateVirtualServiceInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDeleteGatewayRoute struct {
154}
155
156func (*validateOpDeleteGatewayRoute) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDeleteGatewayRoute) 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.(*DeleteGatewayRouteInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDeleteGatewayRouteInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDeleteMesh struct {
174}
175
176func (*validateOpDeleteMesh) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDeleteMesh) 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.(*DeleteMeshInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDeleteMeshInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDeleteRoute struct {
194}
195
196func (*validateOpDeleteRoute) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDeleteRoute) 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.(*DeleteRouteInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDeleteRouteInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpDeleteVirtualGateway struct {
214}
215
216func (*validateOpDeleteVirtualGateway) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpDeleteVirtualGateway) 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.(*DeleteVirtualGatewayInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpDeleteVirtualGatewayInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDeleteVirtualNode struct {
234}
235
236func (*validateOpDeleteVirtualNode) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDeleteVirtualNode) 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.(*DeleteVirtualNodeInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDeleteVirtualNodeInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDeleteVirtualRouter struct {
254}
255
256func (*validateOpDeleteVirtualRouter) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDeleteVirtualRouter) 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.(*DeleteVirtualRouterInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDeleteVirtualRouterInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDeleteVirtualService struct {
274}
275
276func (*validateOpDeleteVirtualService) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDeleteVirtualService) 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.(*DeleteVirtualServiceInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDeleteVirtualServiceInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDescribeGatewayRoute struct {
294}
295
296func (*validateOpDescribeGatewayRoute) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDescribeGatewayRoute) 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.(*DescribeGatewayRouteInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDescribeGatewayRouteInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDescribeMesh struct {
314}
315
316func (*validateOpDescribeMesh) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDescribeMesh) 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.(*DescribeMeshInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDescribeMeshInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDescribeRoute struct {
334}
335
336func (*validateOpDescribeRoute) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDescribeRoute) 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.(*DescribeRouteInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDescribeRouteInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDescribeVirtualGateway struct {
354}
355
356func (*validateOpDescribeVirtualGateway) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDescribeVirtualGateway) 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.(*DescribeVirtualGatewayInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDescribeVirtualGatewayInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDescribeVirtualNode struct {
374}
375
376func (*validateOpDescribeVirtualNode) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDescribeVirtualNode) 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.(*DescribeVirtualNodeInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDescribeVirtualNodeInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDescribeVirtualRouter struct {
394}
395
396func (*validateOpDescribeVirtualRouter) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDescribeVirtualRouter) 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.(*DescribeVirtualRouterInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDescribeVirtualRouterInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDescribeVirtualService struct {
414}
415
416func (*validateOpDescribeVirtualService) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDescribeVirtualService) 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.(*DescribeVirtualServiceInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDescribeVirtualServiceInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpListGatewayRoutes struct {
434}
435
436func (*validateOpListGatewayRoutes) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpListGatewayRoutes) 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.(*ListGatewayRoutesInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpListGatewayRoutesInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpListRoutes struct {
454}
455
456func (*validateOpListRoutes) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpListRoutes) 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.(*ListRoutesInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpListRoutesInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpListTagsForResource struct {
474}
475
476func (*validateOpListTagsForResource) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpListTagsForResourceInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpListVirtualGateways struct {
494}
495
496func (*validateOpListVirtualGateways) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpListVirtualGateways) 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.(*ListVirtualGatewaysInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpListVirtualGatewaysInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpListVirtualNodes struct {
514}
515
516func (*validateOpListVirtualNodes) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpListVirtualNodes) 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.(*ListVirtualNodesInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpListVirtualNodesInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpListVirtualRouters struct {
534}
535
536func (*validateOpListVirtualRouters) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpListVirtualRouters) 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.(*ListVirtualRoutersInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpListVirtualRoutersInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpListVirtualServices struct {
554}
555
556func (*validateOpListVirtualServices) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpListVirtualServices) 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.(*ListVirtualServicesInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpListVirtualServicesInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpTagResource struct {
574}
575
576func (*validateOpTagResource) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpTagResource) 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.(*TagResourceInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpTagResourceInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpUntagResource struct {
594}
595
596func (*validateOpUntagResource) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpUntagResource) 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.(*UntagResourceInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpUntagResourceInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpUpdateGatewayRoute struct {
614}
615
616func (*validateOpUpdateGatewayRoute) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpUpdateGatewayRoute) 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.(*UpdateGatewayRouteInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpUpdateGatewayRouteInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpUpdateMesh struct {
634}
635
636func (*validateOpUpdateMesh) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpUpdateMesh) 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.(*UpdateMeshInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpUpdateMeshInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpUpdateRoute struct {
654}
655
656func (*validateOpUpdateRoute) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpUpdateRoute) 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.(*UpdateRouteInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpUpdateRouteInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpUpdateVirtualGateway struct {
674}
675
676func (*validateOpUpdateVirtualGateway) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpUpdateVirtualGateway) 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.(*UpdateVirtualGatewayInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpUpdateVirtualGatewayInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpUpdateVirtualNode struct {
694}
695
696func (*validateOpUpdateVirtualNode) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpUpdateVirtualNode) 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.(*UpdateVirtualNodeInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpUpdateVirtualNodeInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpUpdateVirtualRouter struct {
714}
715
716func (*validateOpUpdateVirtualRouter) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpUpdateVirtualRouter) 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.(*UpdateVirtualRouterInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpUpdateVirtualRouterInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpUpdateVirtualService struct {
734}
735
736func (*validateOpUpdateVirtualService) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpUpdateVirtualService) 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.(*UpdateVirtualServiceInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpUpdateVirtualServiceInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753func addOpCreateGatewayRouteValidationMiddleware(stack *middleware.Stack) error {
754	return stack.Initialize.Add(&validateOpCreateGatewayRoute{}, middleware.After)
755}
756
757func addOpCreateMeshValidationMiddleware(stack *middleware.Stack) error {
758	return stack.Initialize.Add(&validateOpCreateMesh{}, middleware.After)
759}
760
761func addOpCreateRouteValidationMiddleware(stack *middleware.Stack) error {
762	return stack.Initialize.Add(&validateOpCreateRoute{}, middleware.After)
763}
764
765func addOpCreateVirtualGatewayValidationMiddleware(stack *middleware.Stack) error {
766	return stack.Initialize.Add(&validateOpCreateVirtualGateway{}, middleware.After)
767}
768
769func addOpCreateVirtualNodeValidationMiddleware(stack *middleware.Stack) error {
770	return stack.Initialize.Add(&validateOpCreateVirtualNode{}, middleware.After)
771}
772
773func addOpCreateVirtualRouterValidationMiddleware(stack *middleware.Stack) error {
774	return stack.Initialize.Add(&validateOpCreateVirtualRouter{}, middleware.After)
775}
776
777func addOpCreateVirtualServiceValidationMiddleware(stack *middleware.Stack) error {
778	return stack.Initialize.Add(&validateOpCreateVirtualService{}, middleware.After)
779}
780
781func addOpDeleteGatewayRouteValidationMiddleware(stack *middleware.Stack) error {
782	return stack.Initialize.Add(&validateOpDeleteGatewayRoute{}, middleware.After)
783}
784
785func addOpDeleteMeshValidationMiddleware(stack *middleware.Stack) error {
786	return stack.Initialize.Add(&validateOpDeleteMesh{}, middleware.After)
787}
788
789func addOpDeleteRouteValidationMiddleware(stack *middleware.Stack) error {
790	return stack.Initialize.Add(&validateOpDeleteRoute{}, middleware.After)
791}
792
793func addOpDeleteVirtualGatewayValidationMiddleware(stack *middleware.Stack) error {
794	return stack.Initialize.Add(&validateOpDeleteVirtualGateway{}, middleware.After)
795}
796
797func addOpDeleteVirtualNodeValidationMiddleware(stack *middleware.Stack) error {
798	return stack.Initialize.Add(&validateOpDeleteVirtualNode{}, middleware.After)
799}
800
801func addOpDeleteVirtualRouterValidationMiddleware(stack *middleware.Stack) error {
802	return stack.Initialize.Add(&validateOpDeleteVirtualRouter{}, middleware.After)
803}
804
805func addOpDeleteVirtualServiceValidationMiddleware(stack *middleware.Stack) error {
806	return stack.Initialize.Add(&validateOpDeleteVirtualService{}, middleware.After)
807}
808
809func addOpDescribeGatewayRouteValidationMiddleware(stack *middleware.Stack) error {
810	return stack.Initialize.Add(&validateOpDescribeGatewayRoute{}, middleware.After)
811}
812
813func addOpDescribeMeshValidationMiddleware(stack *middleware.Stack) error {
814	return stack.Initialize.Add(&validateOpDescribeMesh{}, middleware.After)
815}
816
817func addOpDescribeRouteValidationMiddleware(stack *middleware.Stack) error {
818	return stack.Initialize.Add(&validateOpDescribeRoute{}, middleware.After)
819}
820
821func addOpDescribeVirtualGatewayValidationMiddleware(stack *middleware.Stack) error {
822	return stack.Initialize.Add(&validateOpDescribeVirtualGateway{}, middleware.After)
823}
824
825func addOpDescribeVirtualNodeValidationMiddleware(stack *middleware.Stack) error {
826	return stack.Initialize.Add(&validateOpDescribeVirtualNode{}, middleware.After)
827}
828
829func addOpDescribeVirtualRouterValidationMiddleware(stack *middleware.Stack) error {
830	return stack.Initialize.Add(&validateOpDescribeVirtualRouter{}, middleware.After)
831}
832
833func addOpDescribeVirtualServiceValidationMiddleware(stack *middleware.Stack) error {
834	return stack.Initialize.Add(&validateOpDescribeVirtualService{}, middleware.After)
835}
836
837func addOpListGatewayRoutesValidationMiddleware(stack *middleware.Stack) error {
838	return stack.Initialize.Add(&validateOpListGatewayRoutes{}, middleware.After)
839}
840
841func addOpListRoutesValidationMiddleware(stack *middleware.Stack) error {
842	return stack.Initialize.Add(&validateOpListRoutes{}, middleware.After)
843}
844
845func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
846	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
847}
848
849func addOpListVirtualGatewaysValidationMiddleware(stack *middleware.Stack) error {
850	return stack.Initialize.Add(&validateOpListVirtualGateways{}, middleware.After)
851}
852
853func addOpListVirtualNodesValidationMiddleware(stack *middleware.Stack) error {
854	return stack.Initialize.Add(&validateOpListVirtualNodes{}, middleware.After)
855}
856
857func addOpListVirtualRoutersValidationMiddleware(stack *middleware.Stack) error {
858	return stack.Initialize.Add(&validateOpListVirtualRouters{}, middleware.After)
859}
860
861func addOpListVirtualServicesValidationMiddleware(stack *middleware.Stack) error {
862	return stack.Initialize.Add(&validateOpListVirtualServices{}, middleware.After)
863}
864
865func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
866	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
867}
868
869func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
870	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
871}
872
873func addOpUpdateGatewayRouteValidationMiddleware(stack *middleware.Stack) error {
874	return stack.Initialize.Add(&validateOpUpdateGatewayRoute{}, middleware.After)
875}
876
877func addOpUpdateMeshValidationMiddleware(stack *middleware.Stack) error {
878	return stack.Initialize.Add(&validateOpUpdateMesh{}, middleware.After)
879}
880
881func addOpUpdateRouteValidationMiddleware(stack *middleware.Stack) error {
882	return stack.Initialize.Add(&validateOpUpdateRoute{}, middleware.After)
883}
884
885func addOpUpdateVirtualGatewayValidationMiddleware(stack *middleware.Stack) error {
886	return stack.Initialize.Add(&validateOpUpdateVirtualGateway{}, middleware.After)
887}
888
889func addOpUpdateVirtualNodeValidationMiddleware(stack *middleware.Stack) error {
890	return stack.Initialize.Add(&validateOpUpdateVirtualNode{}, middleware.After)
891}
892
893func addOpUpdateVirtualRouterValidationMiddleware(stack *middleware.Stack) error {
894	return stack.Initialize.Add(&validateOpUpdateVirtualRouter{}, middleware.After)
895}
896
897func addOpUpdateVirtualServiceValidationMiddleware(stack *middleware.Stack) error {
898	return stack.Initialize.Add(&validateOpUpdateVirtualService{}, middleware.After)
899}
900
901func validateAccessLog(v types.AccessLog) error {
902	if v == nil {
903		return nil
904	}
905	invalidParams := smithy.InvalidParamsError{Context: "AccessLog"}
906	switch uv := v.(type) {
907	case *types.AccessLogMemberFile:
908		if err := validateFileAccessLog(&uv.Value); err != nil {
909			invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError))
910		}
911
912	}
913	if invalidParams.Len() > 0 {
914		return invalidParams
915	} else {
916		return nil
917	}
918}
919
920func validateAwsCloudMapInstanceAttribute(v *types.AwsCloudMapInstanceAttribute) error {
921	if v == nil {
922		return nil
923	}
924	invalidParams := smithy.InvalidParamsError{Context: "AwsCloudMapInstanceAttribute"}
925	if v.Key == nil {
926		invalidParams.Add(smithy.NewErrParamRequired("Key"))
927	}
928	if v.Value == nil {
929		invalidParams.Add(smithy.NewErrParamRequired("Value"))
930	}
931	if invalidParams.Len() > 0 {
932		return invalidParams
933	} else {
934		return nil
935	}
936}
937
938func validateAwsCloudMapInstanceAttributes(v []types.AwsCloudMapInstanceAttribute) error {
939	if v == nil {
940		return nil
941	}
942	invalidParams := smithy.InvalidParamsError{Context: "AwsCloudMapInstanceAttributes"}
943	for i := range v {
944		if err := validateAwsCloudMapInstanceAttribute(&v[i]); err != nil {
945			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
946		}
947	}
948	if invalidParams.Len() > 0 {
949		return invalidParams
950	} else {
951		return nil
952	}
953}
954
955func validateAwsCloudMapServiceDiscovery(v *types.AwsCloudMapServiceDiscovery) error {
956	if v == nil {
957		return nil
958	}
959	invalidParams := smithy.InvalidParamsError{Context: "AwsCloudMapServiceDiscovery"}
960	if v.NamespaceName == nil {
961		invalidParams.Add(smithy.NewErrParamRequired("NamespaceName"))
962	}
963	if v.ServiceName == nil {
964		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
965	}
966	if v.Attributes != nil {
967		if err := validateAwsCloudMapInstanceAttributes(v.Attributes); err != nil {
968			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
969		}
970	}
971	if invalidParams.Len() > 0 {
972		return invalidParams
973	} else {
974		return nil
975	}
976}
977
978func validateBackend(v types.Backend) error {
979	if v == nil {
980		return nil
981	}
982	invalidParams := smithy.InvalidParamsError{Context: "Backend"}
983	switch uv := v.(type) {
984	case *types.BackendMemberVirtualService:
985		if err := validateVirtualServiceBackend(&uv.Value); err != nil {
986			invalidParams.AddNested("[virtualService]", err.(smithy.InvalidParamsError))
987		}
988
989	}
990	if invalidParams.Len() > 0 {
991		return invalidParams
992	} else {
993		return nil
994	}
995}
996
997func validateBackendDefaults(v *types.BackendDefaults) error {
998	if v == nil {
999		return nil
1000	}
1001	invalidParams := smithy.InvalidParamsError{Context: "BackendDefaults"}
1002	if v.ClientPolicy != nil {
1003		if err := validateClientPolicy(v.ClientPolicy); err != nil {
1004			invalidParams.AddNested("ClientPolicy", err.(smithy.InvalidParamsError))
1005		}
1006	}
1007	if invalidParams.Len() > 0 {
1008		return invalidParams
1009	} else {
1010		return nil
1011	}
1012}
1013
1014func validateBackends(v []types.Backend) error {
1015	if v == nil {
1016		return nil
1017	}
1018	invalidParams := smithy.InvalidParamsError{Context: "Backends"}
1019	for i := range v {
1020		if err := validateBackend(v[i]); err != nil {
1021			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1022		}
1023	}
1024	if invalidParams.Len() > 0 {
1025		return invalidParams
1026	} else {
1027		return nil
1028	}
1029}
1030
1031func validateClientPolicy(v *types.ClientPolicy) error {
1032	if v == nil {
1033		return nil
1034	}
1035	invalidParams := smithy.InvalidParamsError{Context: "ClientPolicy"}
1036	if v.Tls != nil {
1037		if err := validateClientPolicyTls(v.Tls); err != nil {
1038			invalidParams.AddNested("Tls", err.(smithy.InvalidParamsError))
1039		}
1040	}
1041	if invalidParams.Len() > 0 {
1042		return invalidParams
1043	} else {
1044		return nil
1045	}
1046}
1047
1048func validateClientPolicyTls(v *types.ClientPolicyTls) error {
1049	if v == nil {
1050		return nil
1051	}
1052	invalidParams := smithy.InvalidParamsError{Context: "ClientPolicyTls"}
1053	if v.Validation == nil {
1054		invalidParams.Add(smithy.NewErrParamRequired("Validation"))
1055	} else if v.Validation != nil {
1056		if err := validateTlsValidationContext(v.Validation); err != nil {
1057			invalidParams.AddNested("Validation", err.(smithy.InvalidParamsError))
1058		}
1059	}
1060	if invalidParams.Len() > 0 {
1061		return invalidParams
1062	} else {
1063		return nil
1064	}
1065}
1066
1067func validateDnsServiceDiscovery(v *types.DnsServiceDiscovery) error {
1068	if v == nil {
1069		return nil
1070	}
1071	invalidParams := smithy.InvalidParamsError{Context: "DnsServiceDiscovery"}
1072	if v.Hostname == nil {
1073		invalidParams.Add(smithy.NewErrParamRequired("Hostname"))
1074	}
1075	if invalidParams.Len() > 0 {
1076		return invalidParams
1077	} else {
1078		return nil
1079	}
1080}
1081
1082func validateEgressFilter(v *types.EgressFilter) error {
1083	if v == nil {
1084		return nil
1085	}
1086	invalidParams := smithy.InvalidParamsError{Context: "EgressFilter"}
1087	if len(v.Type) == 0 {
1088		invalidParams.Add(smithy.NewErrParamRequired("Type"))
1089	}
1090	if invalidParams.Len() > 0 {
1091		return invalidParams
1092	} else {
1093		return nil
1094	}
1095}
1096
1097func validateFileAccessLog(v *types.FileAccessLog) error {
1098	if v == nil {
1099		return nil
1100	}
1101	invalidParams := smithy.InvalidParamsError{Context: "FileAccessLog"}
1102	if v.Path == nil {
1103		invalidParams.Add(smithy.NewErrParamRequired("Path"))
1104	}
1105	if invalidParams.Len() > 0 {
1106		return invalidParams
1107	} else {
1108		return nil
1109	}
1110}
1111
1112func validateGatewayRouteSpec(v *types.GatewayRouteSpec) error {
1113	if v == nil {
1114		return nil
1115	}
1116	invalidParams := smithy.InvalidParamsError{Context: "GatewayRouteSpec"}
1117	if v.HttpRoute != nil {
1118		if err := validateHttpGatewayRoute(v.HttpRoute); err != nil {
1119			invalidParams.AddNested("HttpRoute", err.(smithy.InvalidParamsError))
1120		}
1121	}
1122	if v.Http2Route != nil {
1123		if err := validateHttpGatewayRoute(v.Http2Route); err != nil {
1124			invalidParams.AddNested("Http2Route", err.(smithy.InvalidParamsError))
1125		}
1126	}
1127	if v.GrpcRoute != nil {
1128		if err := validateGrpcGatewayRoute(v.GrpcRoute); err != nil {
1129			invalidParams.AddNested("GrpcRoute", err.(smithy.InvalidParamsError))
1130		}
1131	}
1132	if invalidParams.Len() > 0 {
1133		return invalidParams
1134	} else {
1135		return nil
1136	}
1137}
1138
1139func validateGatewayRouteTarget(v *types.GatewayRouteTarget) error {
1140	if v == nil {
1141		return nil
1142	}
1143	invalidParams := smithy.InvalidParamsError{Context: "GatewayRouteTarget"}
1144	if v.VirtualService == nil {
1145		invalidParams.Add(smithy.NewErrParamRequired("VirtualService"))
1146	} else if v.VirtualService != nil {
1147		if err := validateGatewayRouteVirtualService(v.VirtualService); err != nil {
1148			invalidParams.AddNested("VirtualService", err.(smithy.InvalidParamsError))
1149		}
1150	}
1151	if invalidParams.Len() > 0 {
1152		return invalidParams
1153	} else {
1154		return nil
1155	}
1156}
1157
1158func validateGatewayRouteVirtualService(v *types.GatewayRouteVirtualService) error {
1159	if v == nil {
1160		return nil
1161	}
1162	invalidParams := smithy.InvalidParamsError{Context: "GatewayRouteVirtualService"}
1163	if v.VirtualServiceName == nil {
1164		invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName"))
1165	}
1166	if invalidParams.Len() > 0 {
1167		return invalidParams
1168	} else {
1169		return nil
1170	}
1171}
1172
1173func validateGrpcGatewayRoute(v *types.GrpcGatewayRoute) error {
1174	if v == nil {
1175		return nil
1176	}
1177	invalidParams := smithy.InvalidParamsError{Context: "GrpcGatewayRoute"}
1178	if v.Match == nil {
1179		invalidParams.Add(smithy.NewErrParamRequired("Match"))
1180	}
1181	if v.Action == nil {
1182		invalidParams.Add(smithy.NewErrParamRequired("Action"))
1183	} else if v.Action != nil {
1184		if err := validateGrpcGatewayRouteAction(v.Action); err != nil {
1185			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
1186		}
1187	}
1188	if invalidParams.Len() > 0 {
1189		return invalidParams
1190	} else {
1191		return nil
1192	}
1193}
1194
1195func validateGrpcGatewayRouteAction(v *types.GrpcGatewayRouteAction) error {
1196	if v == nil {
1197		return nil
1198	}
1199	invalidParams := smithy.InvalidParamsError{Context: "GrpcGatewayRouteAction"}
1200	if v.Target == nil {
1201		invalidParams.Add(smithy.NewErrParamRequired("Target"))
1202	} else if v.Target != nil {
1203		if err := validateGatewayRouteTarget(v.Target); err != nil {
1204			invalidParams.AddNested("Target", err.(smithy.InvalidParamsError))
1205		}
1206	}
1207	if invalidParams.Len() > 0 {
1208		return invalidParams
1209	} else {
1210		return nil
1211	}
1212}
1213
1214func validateGrpcRetryPolicy(v *types.GrpcRetryPolicy) error {
1215	if v == nil {
1216		return nil
1217	}
1218	invalidParams := smithy.InvalidParamsError{Context: "GrpcRetryPolicy"}
1219	if v.PerRetryTimeout == nil {
1220		invalidParams.Add(smithy.NewErrParamRequired("PerRetryTimeout"))
1221	}
1222	if v.MaxRetries == nil {
1223		invalidParams.Add(smithy.NewErrParamRequired("MaxRetries"))
1224	}
1225	if invalidParams.Len() > 0 {
1226		return invalidParams
1227	} else {
1228		return nil
1229	}
1230}
1231
1232func validateGrpcRoute(v *types.GrpcRoute) error {
1233	if v == nil {
1234		return nil
1235	}
1236	invalidParams := smithy.InvalidParamsError{Context: "GrpcRoute"}
1237	if v.Action == nil {
1238		invalidParams.Add(smithy.NewErrParamRequired("Action"))
1239	} else if v.Action != nil {
1240		if err := validateGrpcRouteAction(v.Action); err != nil {
1241			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
1242		}
1243	}
1244	if v.Match == nil {
1245		invalidParams.Add(smithy.NewErrParamRequired("Match"))
1246	} else if v.Match != nil {
1247		if err := validateGrpcRouteMatch(v.Match); err != nil {
1248			invalidParams.AddNested("Match", err.(smithy.InvalidParamsError))
1249		}
1250	}
1251	if v.RetryPolicy != nil {
1252		if err := validateGrpcRetryPolicy(v.RetryPolicy); err != nil {
1253			invalidParams.AddNested("RetryPolicy", err.(smithy.InvalidParamsError))
1254		}
1255	}
1256	if invalidParams.Len() > 0 {
1257		return invalidParams
1258	} else {
1259		return nil
1260	}
1261}
1262
1263func validateGrpcRouteAction(v *types.GrpcRouteAction) error {
1264	if v == nil {
1265		return nil
1266	}
1267	invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteAction"}
1268	if v.WeightedTargets == nil {
1269		invalidParams.Add(smithy.NewErrParamRequired("WeightedTargets"))
1270	} else if v.WeightedTargets != nil {
1271		if err := validateWeightedTargets(v.WeightedTargets); err != nil {
1272			invalidParams.AddNested("WeightedTargets", err.(smithy.InvalidParamsError))
1273		}
1274	}
1275	if invalidParams.Len() > 0 {
1276		return invalidParams
1277	} else {
1278		return nil
1279	}
1280}
1281
1282func validateGrpcRouteMatch(v *types.GrpcRouteMatch) error {
1283	if v == nil {
1284		return nil
1285	}
1286	invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMatch"}
1287	if v.Metadata != nil {
1288		if err := validateGrpcRouteMetadataList(v.Metadata); err != nil {
1289			invalidParams.AddNested("Metadata", err.(smithy.InvalidParamsError))
1290		}
1291	}
1292	if invalidParams.Len() > 0 {
1293		return invalidParams
1294	} else {
1295		return nil
1296	}
1297}
1298
1299func validateGrpcRouteMetadata(v *types.GrpcRouteMetadata) error {
1300	if v == nil {
1301		return nil
1302	}
1303	invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMetadata"}
1304	if v.Name == nil {
1305		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1306	}
1307	if v.Match != nil {
1308		if err := validateGrpcRouteMetadataMatchMethod(v.Match); err != nil {
1309			invalidParams.AddNested("Match", err.(smithy.InvalidParamsError))
1310		}
1311	}
1312	if invalidParams.Len() > 0 {
1313		return invalidParams
1314	} else {
1315		return nil
1316	}
1317}
1318
1319func validateGrpcRouteMetadataList(v []types.GrpcRouteMetadata) error {
1320	if v == nil {
1321		return nil
1322	}
1323	invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMetadataList"}
1324	for i := range v {
1325		if err := validateGrpcRouteMetadata(&v[i]); err != nil {
1326			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1327		}
1328	}
1329	if invalidParams.Len() > 0 {
1330		return invalidParams
1331	} else {
1332		return nil
1333	}
1334}
1335
1336func validateGrpcRouteMetadataMatchMethod(v types.GrpcRouteMetadataMatchMethod) error {
1337	if v == nil {
1338		return nil
1339	}
1340	invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMetadataMatchMethod"}
1341	switch uv := v.(type) {
1342	case *types.GrpcRouteMetadataMatchMethodMemberRange:
1343		if err := validateMatchRange(&uv.Value); err != nil {
1344			invalidParams.AddNested("[range]", err.(smithy.InvalidParamsError))
1345		}
1346
1347	}
1348	if invalidParams.Len() > 0 {
1349		return invalidParams
1350	} else {
1351		return nil
1352	}
1353}
1354
1355func validateHeaderMatchMethod(v types.HeaderMatchMethod) error {
1356	if v == nil {
1357		return nil
1358	}
1359	invalidParams := smithy.InvalidParamsError{Context: "HeaderMatchMethod"}
1360	switch uv := v.(type) {
1361	case *types.HeaderMatchMethodMemberRange:
1362		if err := validateMatchRange(&uv.Value); err != nil {
1363			invalidParams.AddNested("[range]", err.(smithy.InvalidParamsError))
1364		}
1365
1366	}
1367	if invalidParams.Len() > 0 {
1368		return invalidParams
1369	} else {
1370		return nil
1371	}
1372}
1373
1374func validateHealthCheckPolicy(v *types.HealthCheckPolicy) error {
1375	if v == nil {
1376		return nil
1377	}
1378	invalidParams := smithy.InvalidParamsError{Context: "HealthCheckPolicy"}
1379	if v.TimeoutMillis == nil {
1380		invalidParams.Add(smithy.NewErrParamRequired("TimeoutMillis"))
1381	}
1382	if v.IntervalMillis == nil {
1383		invalidParams.Add(smithy.NewErrParamRequired("IntervalMillis"))
1384	}
1385	if len(v.Protocol) == 0 {
1386		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
1387	}
1388	if invalidParams.Len() > 0 {
1389		return invalidParams
1390	} else {
1391		return nil
1392	}
1393}
1394
1395func validateHttpGatewayRoute(v *types.HttpGatewayRoute) error {
1396	if v == nil {
1397		return nil
1398	}
1399	invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRoute"}
1400	if v.Match == nil {
1401		invalidParams.Add(smithy.NewErrParamRequired("Match"))
1402	} else if v.Match != nil {
1403		if err := validateHttpGatewayRouteMatch(v.Match); err != nil {
1404			invalidParams.AddNested("Match", err.(smithy.InvalidParamsError))
1405		}
1406	}
1407	if v.Action == nil {
1408		invalidParams.Add(smithy.NewErrParamRequired("Action"))
1409	} else if v.Action != nil {
1410		if err := validateHttpGatewayRouteAction(v.Action); err != nil {
1411			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
1412		}
1413	}
1414	if invalidParams.Len() > 0 {
1415		return invalidParams
1416	} else {
1417		return nil
1418	}
1419}
1420
1421func validateHttpGatewayRouteAction(v *types.HttpGatewayRouteAction) error {
1422	if v == nil {
1423		return nil
1424	}
1425	invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRouteAction"}
1426	if v.Target == nil {
1427		invalidParams.Add(smithy.NewErrParamRequired("Target"))
1428	} else if v.Target != nil {
1429		if err := validateGatewayRouteTarget(v.Target); err != nil {
1430			invalidParams.AddNested("Target", err.(smithy.InvalidParamsError))
1431		}
1432	}
1433	if invalidParams.Len() > 0 {
1434		return invalidParams
1435	} else {
1436		return nil
1437	}
1438}
1439
1440func validateHttpGatewayRouteMatch(v *types.HttpGatewayRouteMatch) error {
1441	if v == nil {
1442		return nil
1443	}
1444	invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRouteMatch"}
1445	if v.Prefix == nil {
1446		invalidParams.Add(smithy.NewErrParamRequired("Prefix"))
1447	}
1448	if invalidParams.Len() > 0 {
1449		return invalidParams
1450	} else {
1451		return nil
1452	}
1453}
1454
1455func validateHttpRetryPolicy(v *types.HttpRetryPolicy) error {
1456	if v == nil {
1457		return nil
1458	}
1459	invalidParams := smithy.InvalidParamsError{Context: "HttpRetryPolicy"}
1460	if v.PerRetryTimeout == nil {
1461		invalidParams.Add(smithy.NewErrParamRequired("PerRetryTimeout"))
1462	}
1463	if v.MaxRetries == nil {
1464		invalidParams.Add(smithy.NewErrParamRequired("MaxRetries"))
1465	}
1466	if invalidParams.Len() > 0 {
1467		return invalidParams
1468	} else {
1469		return nil
1470	}
1471}
1472
1473func validateHttpRoute(v *types.HttpRoute) error {
1474	if v == nil {
1475		return nil
1476	}
1477	invalidParams := smithy.InvalidParamsError{Context: "HttpRoute"}
1478	if v.Match == nil {
1479		invalidParams.Add(smithy.NewErrParamRequired("Match"))
1480	} else if v.Match != nil {
1481		if err := validateHttpRouteMatch(v.Match); err != nil {
1482			invalidParams.AddNested("Match", err.(smithy.InvalidParamsError))
1483		}
1484	}
1485	if v.Action == nil {
1486		invalidParams.Add(smithy.NewErrParamRequired("Action"))
1487	} else if v.Action != nil {
1488		if err := validateHttpRouteAction(v.Action); err != nil {
1489			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
1490		}
1491	}
1492	if v.RetryPolicy != nil {
1493		if err := validateHttpRetryPolicy(v.RetryPolicy); err != nil {
1494			invalidParams.AddNested("RetryPolicy", err.(smithy.InvalidParamsError))
1495		}
1496	}
1497	if invalidParams.Len() > 0 {
1498		return invalidParams
1499	} else {
1500		return nil
1501	}
1502}
1503
1504func validateHttpRouteAction(v *types.HttpRouteAction) error {
1505	if v == nil {
1506		return nil
1507	}
1508	invalidParams := smithy.InvalidParamsError{Context: "HttpRouteAction"}
1509	if v.WeightedTargets == nil {
1510		invalidParams.Add(smithy.NewErrParamRequired("WeightedTargets"))
1511	} else if v.WeightedTargets != nil {
1512		if err := validateWeightedTargets(v.WeightedTargets); err != nil {
1513			invalidParams.AddNested("WeightedTargets", err.(smithy.InvalidParamsError))
1514		}
1515	}
1516	if invalidParams.Len() > 0 {
1517		return invalidParams
1518	} else {
1519		return nil
1520	}
1521}
1522
1523func validateHttpRouteHeader(v *types.HttpRouteHeader) error {
1524	if v == nil {
1525		return nil
1526	}
1527	invalidParams := smithy.InvalidParamsError{Context: "HttpRouteHeader"}
1528	if v.Name == nil {
1529		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1530	}
1531	if v.Match != nil {
1532		if err := validateHeaderMatchMethod(v.Match); err != nil {
1533			invalidParams.AddNested("Match", err.(smithy.InvalidParamsError))
1534		}
1535	}
1536	if invalidParams.Len() > 0 {
1537		return invalidParams
1538	} else {
1539		return nil
1540	}
1541}
1542
1543func validateHttpRouteHeaders(v []types.HttpRouteHeader) error {
1544	if v == nil {
1545		return nil
1546	}
1547	invalidParams := smithy.InvalidParamsError{Context: "HttpRouteHeaders"}
1548	for i := range v {
1549		if err := validateHttpRouteHeader(&v[i]); err != nil {
1550			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1551		}
1552	}
1553	if invalidParams.Len() > 0 {
1554		return invalidParams
1555	} else {
1556		return nil
1557	}
1558}
1559
1560func validateHttpRouteMatch(v *types.HttpRouteMatch) error {
1561	if v == nil {
1562		return nil
1563	}
1564	invalidParams := smithy.InvalidParamsError{Context: "HttpRouteMatch"}
1565	if v.Prefix == nil {
1566		invalidParams.Add(smithy.NewErrParamRequired("Prefix"))
1567	}
1568	if v.Headers != nil {
1569		if err := validateHttpRouteHeaders(v.Headers); err != nil {
1570			invalidParams.AddNested("Headers", err.(smithy.InvalidParamsError))
1571		}
1572	}
1573	if invalidParams.Len() > 0 {
1574		return invalidParams
1575	} else {
1576		return nil
1577	}
1578}
1579
1580func validateListener(v *types.Listener) error {
1581	if v == nil {
1582		return nil
1583	}
1584	invalidParams := smithy.InvalidParamsError{Context: "Listener"}
1585	if v.PortMapping == nil {
1586		invalidParams.Add(smithy.NewErrParamRequired("PortMapping"))
1587	} else if v.PortMapping != nil {
1588		if err := validatePortMapping(v.PortMapping); err != nil {
1589			invalidParams.AddNested("PortMapping", err.(smithy.InvalidParamsError))
1590		}
1591	}
1592	if v.Tls != nil {
1593		if err := validateListenerTls(v.Tls); err != nil {
1594			invalidParams.AddNested("Tls", err.(smithy.InvalidParamsError))
1595		}
1596	}
1597	if v.HealthCheck != nil {
1598		if err := validateHealthCheckPolicy(v.HealthCheck); err != nil {
1599			invalidParams.AddNested("HealthCheck", err.(smithy.InvalidParamsError))
1600		}
1601	}
1602	if invalidParams.Len() > 0 {
1603		return invalidParams
1604	} else {
1605		return nil
1606	}
1607}
1608
1609func validateListeners(v []types.Listener) error {
1610	if v == nil {
1611		return nil
1612	}
1613	invalidParams := smithy.InvalidParamsError{Context: "Listeners"}
1614	for i := range v {
1615		if err := validateListener(&v[i]); err != nil {
1616			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1617		}
1618	}
1619	if invalidParams.Len() > 0 {
1620		return invalidParams
1621	} else {
1622		return nil
1623	}
1624}
1625
1626func validateListenerTls(v *types.ListenerTls) error {
1627	if v == nil {
1628		return nil
1629	}
1630	invalidParams := smithy.InvalidParamsError{Context: "ListenerTls"}
1631	if len(v.Mode) == 0 {
1632		invalidParams.Add(smithy.NewErrParamRequired("Mode"))
1633	}
1634	if v.Certificate == nil {
1635		invalidParams.Add(smithy.NewErrParamRequired("Certificate"))
1636	} else if v.Certificate != nil {
1637		if err := validateListenerTlsCertificate(v.Certificate); err != nil {
1638			invalidParams.AddNested("Certificate", err.(smithy.InvalidParamsError))
1639		}
1640	}
1641	if invalidParams.Len() > 0 {
1642		return invalidParams
1643	} else {
1644		return nil
1645	}
1646}
1647
1648func validateListenerTlsAcmCertificate(v *types.ListenerTlsAcmCertificate) error {
1649	if v == nil {
1650		return nil
1651	}
1652	invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsAcmCertificate"}
1653	if v.CertificateArn == nil {
1654		invalidParams.Add(smithy.NewErrParamRequired("CertificateArn"))
1655	}
1656	if invalidParams.Len() > 0 {
1657		return invalidParams
1658	} else {
1659		return nil
1660	}
1661}
1662
1663func validateListenerTlsCertificate(v types.ListenerTlsCertificate) error {
1664	if v == nil {
1665		return nil
1666	}
1667	invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsCertificate"}
1668	switch uv := v.(type) {
1669	case *types.ListenerTlsCertificateMemberAcm:
1670		if err := validateListenerTlsAcmCertificate(&uv.Value); err != nil {
1671			invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError))
1672		}
1673
1674	case *types.ListenerTlsCertificateMemberFile:
1675		if err := validateListenerTlsFileCertificate(&uv.Value); err != nil {
1676			invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError))
1677		}
1678
1679	}
1680	if invalidParams.Len() > 0 {
1681		return invalidParams
1682	} else {
1683		return nil
1684	}
1685}
1686
1687func validateListenerTlsFileCertificate(v *types.ListenerTlsFileCertificate) error {
1688	if v == nil {
1689		return nil
1690	}
1691	invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsFileCertificate"}
1692	if v.CertificateChain == nil {
1693		invalidParams.Add(smithy.NewErrParamRequired("CertificateChain"))
1694	}
1695	if v.PrivateKey == nil {
1696		invalidParams.Add(smithy.NewErrParamRequired("PrivateKey"))
1697	}
1698	if invalidParams.Len() > 0 {
1699		return invalidParams
1700	} else {
1701		return nil
1702	}
1703}
1704
1705func validateLogging(v *types.Logging) error {
1706	if v == nil {
1707		return nil
1708	}
1709	invalidParams := smithy.InvalidParamsError{Context: "Logging"}
1710	if v.AccessLog != nil {
1711		if err := validateAccessLog(v.AccessLog); err != nil {
1712			invalidParams.AddNested("AccessLog", err.(smithy.InvalidParamsError))
1713		}
1714	}
1715	if invalidParams.Len() > 0 {
1716		return invalidParams
1717	} else {
1718		return nil
1719	}
1720}
1721
1722func validateMatchRange(v *types.MatchRange) error {
1723	if v == nil {
1724		return nil
1725	}
1726	invalidParams := smithy.InvalidParamsError{Context: "MatchRange"}
1727	if v.Start == nil {
1728		invalidParams.Add(smithy.NewErrParamRequired("Start"))
1729	}
1730	if v.End == nil {
1731		invalidParams.Add(smithy.NewErrParamRequired("End"))
1732	}
1733	if invalidParams.Len() > 0 {
1734		return invalidParams
1735	} else {
1736		return nil
1737	}
1738}
1739
1740func validateMeshSpec(v *types.MeshSpec) error {
1741	if v == nil {
1742		return nil
1743	}
1744	invalidParams := smithy.InvalidParamsError{Context: "MeshSpec"}
1745	if v.EgressFilter != nil {
1746		if err := validateEgressFilter(v.EgressFilter); err != nil {
1747			invalidParams.AddNested("EgressFilter", err.(smithy.InvalidParamsError))
1748		}
1749	}
1750	if invalidParams.Len() > 0 {
1751		return invalidParams
1752	} else {
1753		return nil
1754	}
1755}
1756
1757func validatePortMapping(v *types.PortMapping) error {
1758	if v == nil {
1759		return nil
1760	}
1761	invalidParams := smithy.InvalidParamsError{Context: "PortMapping"}
1762	if len(v.Protocol) == 0 {
1763		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
1764	}
1765	if invalidParams.Len() > 0 {
1766		return invalidParams
1767	} else {
1768		return nil
1769	}
1770}
1771
1772func validateRouteSpec(v *types.RouteSpec) error {
1773	if v == nil {
1774		return nil
1775	}
1776	invalidParams := smithy.InvalidParamsError{Context: "RouteSpec"}
1777	if v.HttpRoute != nil {
1778		if err := validateHttpRoute(v.HttpRoute); err != nil {
1779			invalidParams.AddNested("HttpRoute", err.(smithy.InvalidParamsError))
1780		}
1781	}
1782	if v.TcpRoute != nil {
1783		if err := validateTcpRoute(v.TcpRoute); err != nil {
1784			invalidParams.AddNested("TcpRoute", err.(smithy.InvalidParamsError))
1785		}
1786	}
1787	if v.Http2Route != nil {
1788		if err := validateHttpRoute(v.Http2Route); err != nil {
1789			invalidParams.AddNested("Http2Route", err.(smithy.InvalidParamsError))
1790		}
1791	}
1792	if v.GrpcRoute != nil {
1793		if err := validateGrpcRoute(v.GrpcRoute); err != nil {
1794			invalidParams.AddNested("GrpcRoute", err.(smithy.InvalidParamsError))
1795		}
1796	}
1797	if invalidParams.Len() > 0 {
1798		return invalidParams
1799	} else {
1800		return nil
1801	}
1802}
1803
1804func validateServiceDiscovery(v types.ServiceDiscovery) error {
1805	if v == nil {
1806		return nil
1807	}
1808	invalidParams := smithy.InvalidParamsError{Context: "ServiceDiscovery"}
1809	switch uv := v.(type) {
1810	case *types.ServiceDiscoveryMemberAwsCloudMap:
1811		if err := validateAwsCloudMapServiceDiscovery(&uv.Value); err != nil {
1812			invalidParams.AddNested("[awsCloudMap]", err.(smithy.InvalidParamsError))
1813		}
1814
1815	case *types.ServiceDiscoveryMemberDns:
1816		if err := validateDnsServiceDiscovery(&uv.Value); err != nil {
1817			invalidParams.AddNested("[dns]", err.(smithy.InvalidParamsError))
1818		}
1819
1820	}
1821	if invalidParams.Len() > 0 {
1822		return invalidParams
1823	} else {
1824		return nil
1825	}
1826}
1827
1828func validateTagList(v []types.TagRef) error {
1829	if v == nil {
1830		return nil
1831	}
1832	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
1833	for i := range v {
1834		if err := validateTagRef(&v[i]); err != nil {
1835			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1836		}
1837	}
1838	if invalidParams.Len() > 0 {
1839		return invalidParams
1840	} else {
1841		return nil
1842	}
1843}
1844
1845func validateTagRef(v *types.TagRef) error {
1846	if v == nil {
1847		return nil
1848	}
1849	invalidParams := smithy.InvalidParamsError{Context: "TagRef"}
1850	if v.Key == nil {
1851		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1852	}
1853	if invalidParams.Len() > 0 {
1854		return invalidParams
1855	} else {
1856		return nil
1857	}
1858}
1859
1860func validateTcpRoute(v *types.TcpRoute) error {
1861	if v == nil {
1862		return nil
1863	}
1864	invalidParams := smithy.InvalidParamsError{Context: "TcpRoute"}
1865	if v.Action == nil {
1866		invalidParams.Add(smithy.NewErrParamRequired("Action"))
1867	} else if v.Action != nil {
1868		if err := validateTcpRouteAction(v.Action); err != nil {
1869			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
1870		}
1871	}
1872	if invalidParams.Len() > 0 {
1873		return invalidParams
1874	} else {
1875		return nil
1876	}
1877}
1878
1879func validateTcpRouteAction(v *types.TcpRouteAction) error {
1880	if v == nil {
1881		return nil
1882	}
1883	invalidParams := smithy.InvalidParamsError{Context: "TcpRouteAction"}
1884	if v.WeightedTargets == nil {
1885		invalidParams.Add(smithy.NewErrParamRequired("WeightedTargets"))
1886	} else if v.WeightedTargets != nil {
1887		if err := validateWeightedTargets(v.WeightedTargets); err != nil {
1888			invalidParams.AddNested("WeightedTargets", err.(smithy.InvalidParamsError))
1889		}
1890	}
1891	if invalidParams.Len() > 0 {
1892		return invalidParams
1893	} else {
1894		return nil
1895	}
1896}
1897
1898func validateTlsValidationContext(v *types.TlsValidationContext) error {
1899	if v == nil {
1900		return nil
1901	}
1902	invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContext"}
1903	if v.Trust == nil {
1904		invalidParams.Add(smithy.NewErrParamRequired("Trust"))
1905	} else if v.Trust != nil {
1906		if err := validateTlsValidationContextTrust(v.Trust); err != nil {
1907			invalidParams.AddNested("Trust", err.(smithy.InvalidParamsError))
1908		}
1909	}
1910	if invalidParams.Len() > 0 {
1911		return invalidParams
1912	} else {
1913		return nil
1914	}
1915}
1916
1917func validateTlsValidationContextAcmTrust(v *types.TlsValidationContextAcmTrust) error {
1918	if v == nil {
1919		return nil
1920	}
1921	invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContextAcmTrust"}
1922	if v.CertificateAuthorityArns == nil {
1923		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArns"))
1924	}
1925	if invalidParams.Len() > 0 {
1926		return invalidParams
1927	} else {
1928		return nil
1929	}
1930}
1931
1932func validateTlsValidationContextFileTrust(v *types.TlsValidationContextFileTrust) error {
1933	if v == nil {
1934		return nil
1935	}
1936	invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContextFileTrust"}
1937	if v.CertificateChain == nil {
1938		invalidParams.Add(smithy.NewErrParamRequired("CertificateChain"))
1939	}
1940	if invalidParams.Len() > 0 {
1941		return invalidParams
1942	} else {
1943		return nil
1944	}
1945}
1946
1947func validateTlsValidationContextTrust(v types.TlsValidationContextTrust) error {
1948	if v == nil {
1949		return nil
1950	}
1951	invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContextTrust"}
1952	switch uv := v.(type) {
1953	case *types.TlsValidationContextTrustMemberAcm:
1954		if err := validateTlsValidationContextAcmTrust(&uv.Value); err != nil {
1955			invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError))
1956		}
1957
1958	case *types.TlsValidationContextTrustMemberFile:
1959		if err := validateTlsValidationContextFileTrust(&uv.Value); err != nil {
1960			invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError))
1961		}
1962
1963	}
1964	if invalidParams.Len() > 0 {
1965		return invalidParams
1966	} else {
1967		return nil
1968	}
1969}
1970
1971func validateVirtualGatewayAccessLog(v types.VirtualGatewayAccessLog) error {
1972	if v == nil {
1973		return nil
1974	}
1975	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayAccessLog"}
1976	switch uv := v.(type) {
1977	case *types.VirtualGatewayAccessLogMemberFile:
1978		if err := validateVirtualGatewayFileAccessLog(&uv.Value); err != nil {
1979			invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError))
1980		}
1981
1982	}
1983	if invalidParams.Len() > 0 {
1984		return invalidParams
1985	} else {
1986		return nil
1987	}
1988}
1989
1990func validateVirtualGatewayBackendDefaults(v *types.VirtualGatewayBackendDefaults) error {
1991	if v == nil {
1992		return nil
1993	}
1994	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayBackendDefaults"}
1995	if v.ClientPolicy != nil {
1996		if err := validateVirtualGatewayClientPolicy(v.ClientPolicy); err != nil {
1997			invalidParams.AddNested("ClientPolicy", err.(smithy.InvalidParamsError))
1998		}
1999	}
2000	if invalidParams.Len() > 0 {
2001		return invalidParams
2002	} else {
2003		return nil
2004	}
2005}
2006
2007func validateVirtualGatewayClientPolicy(v *types.VirtualGatewayClientPolicy) error {
2008	if v == nil {
2009		return nil
2010	}
2011	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayClientPolicy"}
2012	if v.Tls != nil {
2013		if err := validateVirtualGatewayClientPolicyTls(v.Tls); err != nil {
2014			invalidParams.AddNested("Tls", err.(smithy.InvalidParamsError))
2015		}
2016	}
2017	if invalidParams.Len() > 0 {
2018		return invalidParams
2019	} else {
2020		return nil
2021	}
2022}
2023
2024func validateVirtualGatewayClientPolicyTls(v *types.VirtualGatewayClientPolicyTls) error {
2025	if v == nil {
2026		return nil
2027	}
2028	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayClientPolicyTls"}
2029	if v.Validation == nil {
2030		invalidParams.Add(smithy.NewErrParamRequired("Validation"))
2031	} else if v.Validation != nil {
2032		if err := validateVirtualGatewayTlsValidationContext(v.Validation); err != nil {
2033			invalidParams.AddNested("Validation", err.(smithy.InvalidParamsError))
2034		}
2035	}
2036	if invalidParams.Len() > 0 {
2037		return invalidParams
2038	} else {
2039		return nil
2040	}
2041}
2042
2043func validateVirtualGatewayFileAccessLog(v *types.VirtualGatewayFileAccessLog) error {
2044	if v == nil {
2045		return nil
2046	}
2047	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayFileAccessLog"}
2048	if v.Path == nil {
2049		invalidParams.Add(smithy.NewErrParamRequired("Path"))
2050	}
2051	if invalidParams.Len() > 0 {
2052		return invalidParams
2053	} else {
2054		return nil
2055	}
2056}
2057
2058func validateVirtualGatewayHealthCheckPolicy(v *types.VirtualGatewayHealthCheckPolicy) error {
2059	if v == nil {
2060		return nil
2061	}
2062	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayHealthCheckPolicy"}
2063	if v.TimeoutMillis == nil {
2064		invalidParams.Add(smithy.NewErrParamRequired("TimeoutMillis"))
2065	}
2066	if v.IntervalMillis == nil {
2067		invalidParams.Add(smithy.NewErrParamRequired("IntervalMillis"))
2068	}
2069	if len(v.Protocol) == 0 {
2070		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
2071	}
2072	if invalidParams.Len() > 0 {
2073		return invalidParams
2074	} else {
2075		return nil
2076	}
2077}
2078
2079func validateVirtualGatewayListener(v *types.VirtualGatewayListener) error {
2080	if v == nil {
2081		return nil
2082	}
2083	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListener"}
2084	if v.HealthCheck != nil {
2085		if err := validateVirtualGatewayHealthCheckPolicy(v.HealthCheck); err != nil {
2086			invalidParams.AddNested("HealthCheck", err.(smithy.InvalidParamsError))
2087		}
2088	}
2089	if v.PortMapping == nil {
2090		invalidParams.Add(smithy.NewErrParamRequired("PortMapping"))
2091	} else if v.PortMapping != nil {
2092		if err := validateVirtualGatewayPortMapping(v.PortMapping); err != nil {
2093			invalidParams.AddNested("PortMapping", err.(smithy.InvalidParamsError))
2094		}
2095	}
2096	if v.Tls != nil {
2097		if err := validateVirtualGatewayListenerTls(v.Tls); err != nil {
2098			invalidParams.AddNested("Tls", err.(smithy.InvalidParamsError))
2099		}
2100	}
2101	if invalidParams.Len() > 0 {
2102		return invalidParams
2103	} else {
2104		return nil
2105	}
2106}
2107
2108func validateVirtualGatewayListeners(v []types.VirtualGatewayListener) error {
2109	if v == nil {
2110		return nil
2111	}
2112	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListeners"}
2113	for i := range v {
2114		if err := validateVirtualGatewayListener(&v[i]); err != nil {
2115			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2116		}
2117	}
2118	if invalidParams.Len() > 0 {
2119		return invalidParams
2120	} else {
2121		return nil
2122	}
2123}
2124
2125func validateVirtualGatewayListenerTls(v *types.VirtualGatewayListenerTls) error {
2126	if v == nil {
2127		return nil
2128	}
2129	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTls"}
2130	if len(v.Mode) == 0 {
2131		invalidParams.Add(smithy.NewErrParamRequired("Mode"))
2132	}
2133	if v.Certificate == nil {
2134		invalidParams.Add(smithy.NewErrParamRequired("Certificate"))
2135	} else if v.Certificate != nil {
2136		if err := validateVirtualGatewayListenerTlsCertificate(v.Certificate); err != nil {
2137			invalidParams.AddNested("Certificate", err.(smithy.InvalidParamsError))
2138		}
2139	}
2140	if invalidParams.Len() > 0 {
2141		return invalidParams
2142	} else {
2143		return nil
2144	}
2145}
2146
2147func validateVirtualGatewayListenerTlsAcmCertificate(v *types.VirtualGatewayListenerTlsAcmCertificate) error {
2148	if v == nil {
2149		return nil
2150	}
2151	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsAcmCertificate"}
2152	if v.CertificateArn == nil {
2153		invalidParams.Add(smithy.NewErrParamRequired("CertificateArn"))
2154	}
2155	if invalidParams.Len() > 0 {
2156		return invalidParams
2157	} else {
2158		return nil
2159	}
2160}
2161
2162func validateVirtualGatewayListenerTlsCertificate(v types.VirtualGatewayListenerTlsCertificate) error {
2163	if v == nil {
2164		return nil
2165	}
2166	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsCertificate"}
2167	switch uv := v.(type) {
2168	case *types.VirtualGatewayListenerTlsCertificateMemberAcm:
2169		if err := validateVirtualGatewayListenerTlsAcmCertificate(&uv.Value); err != nil {
2170			invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError))
2171		}
2172
2173	case *types.VirtualGatewayListenerTlsCertificateMemberFile:
2174		if err := validateVirtualGatewayListenerTlsFileCertificate(&uv.Value); err != nil {
2175			invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError))
2176		}
2177
2178	}
2179	if invalidParams.Len() > 0 {
2180		return invalidParams
2181	} else {
2182		return nil
2183	}
2184}
2185
2186func validateVirtualGatewayListenerTlsFileCertificate(v *types.VirtualGatewayListenerTlsFileCertificate) error {
2187	if v == nil {
2188		return nil
2189	}
2190	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsFileCertificate"}
2191	if v.CertificateChain == nil {
2192		invalidParams.Add(smithy.NewErrParamRequired("CertificateChain"))
2193	}
2194	if v.PrivateKey == nil {
2195		invalidParams.Add(smithy.NewErrParamRequired("PrivateKey"))
2196	}
2197	if invalidParams.Len() > 0 {
2198		return invalidParams
2199	} else {
2200		return nil
2201	}
2202}
2203
2204func validateVirtualGatewayLogging(v *types.VirtualGatewayLogging) error {
2205	if v == nil {
2206		return nil
2207	}
2208	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayLogging"}
2209	if v.AccessLog != nil {
2210		if err := validateVirtualGatewayAccessLog(v.AccessLog); err != nil {
2211			invalidParams.AddNested("AccessLog", err.(smithy.InvalidParamsError))
2212		}
2213	}
2214	if invalidParams.Len() > 0 {
2215		return invalidParams
2216	} else {
2217		return nil
2218	}
2219}
2220
2221func validateVirtualGatewayPortMapping(v *types.VirtualGatewayPortMapping) error {
2222	if v == nil {
2223		return nil
2224	}
2225	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayPortMapping"}
2226	if len(v.Protocol) == 0 {
2227		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
2228	}
2229	if invalidParams.Len() > 0 {
2230		return invalidParams
2231	} else {
2232		return nil
2233	}
2234}
2235
2236func validateVirtualGatewaySpec(v *types.VirtualGatewaySpec) error {
2237	if v == nil {
2238		return nil
2239	}
2240	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewaySpec"}
2241	if v.BackendDefaults != nil {
2242		if err := validateVirtualGatewayBackendDefaults(v.BackendDefaults); err != nil {
2243			invalidParams.AddNested("BackendDefaults", err.(smithy.InvalidParamsError))
2244		}
2245	}
2246	if v.Listeners == nil {
2247		invalidParams.Add(smithy.NewErrParamRequired("Listeners"))
2248	} else if v.Listeners != nil {
2249		if err := validateVirtualGatewayListeners(v.Listeners); err != nil {
2250			invalidParams.AddNested("Listeners", err.(smithy.InvalidParamsError))
2251		}
2252	}
2253	if v.Logging != nil {
2254		if err := validateVirtualGatewayLogging(v.Logging); err != nil {
2255			invalidParams.AddNested("Logging", err.(smithy.InvalidParamsError))
2256		}
2257	}
2258	if invalidParams.Len() > 0 {
2259		return invalidParams
2260	} else {
2261		return nil
2262	}
2263}
2264
2265func validateVirtualGatewayTlsValidationContext(v *types.VirtualGatewayTlsValidationContext) error {
2266	if v == nil {
2267		return nil
2268	}
2269	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContext"}
2270	if v.Trust == nil {
2271		invalidParams.Add(smithy.NewErrParamRequired("Trust"))
2272	} else if v.Trust != nil {
2273		if err := validateVirtualGatewayTlsValidationContextTrust(v.Trust); err != nil {
2274			invalidParams.AddNested("Trust", err.(smithy.InvalidParamsError))
2275		}
2276	}
2277	if invalidParams.Len() > 0 {
2278		return invalidParams
2279	} else {
2280		return nil
2281	}
2282}
2283
2284func validateVirtualGatewayTlsValidationContextAcmTrust(v *types.VirtualGatewayTlsValidationContextAcmTrust) error {
2285	if v == nil {
2286		return nil
2287	}
2288	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContextAcmTrust"}
2289	if v.CertificateAuthorityArns == nil {
2290		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArns"))
2291	}
2292	if invalidParams.Len() > 0 {
2293		return invalidParams
2294	} else {
2295		return nil
2296	}
2297}
2298
2299func validateVirtualGatewayTlsValidationContextFileTrust(v *types.VirtualGatewayTlsValidationContextFileTrust) error {
2300	if v == nil {
2301		return nil
2302	}
2303	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContextFileTrust"}
2304	if v.CertificateChain == nil {
2305		invalidParams.Add(smithy.NewErrParamRequired("CertificateChain"))
2306	}
2307	if invalidParams.Len() > 0 {
2308		return invalidParams
2309	} else {
2310		return nil
2311	}
2312}
2313
2314func validateVirtualGatewayTlsValidationContextTrust(v types.VirtualGatewayTlsValidationContextTrust) error {
2315	if v == nil {
2316		return nil
2317	}
2318	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContextTrust"}
2319	switch uv := v.(type) {
2320	case *types.VirtualGatewayTlsValidationContextTrustMemberAcm:
2321		if err := validateVirtualGatewayTlsValidationContextAcmTrust(&uv.Value); err != nil {
2322			invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError))
2323		}
2324
2325	case *types.VirtualGatewayTlsValidationContextTrustMemberFile:
2326		if err := validateVirtualGatewayTlsValidationContextFileTrust(&uv.Value); err != nil {
2327			invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError))
2328		}
2329
2330	}
2331	if invalidParams.Len() > 0 {
2332		return invalidParams
2333	} else {
2334		return nil
2335	}
2336}
2337
2338func validateVirtualNodeServiceProvider(v *types.VirtualNodeServiceProvider) error {
2339	if v == nil {
2340		return nil
2341	}
2342	invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeServiceProvider"}
2343	if v.VirtualNodeName == nil {
2344		invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName"))
2345	}
2346	if invalidParams.Len() > 0 {
2347		return invalidParams
2348	} else {
2349		return nil
2350	}
2351}
2352
2353func validateVirtualNodeSpec(v *types.VirtualNodeSpec) error {
2354	if v == nil {
2355		return nil
2356	}
2357	invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeSpec"}
2358	if v.ServiceDiscovery != nil {
2359		if err := validateServiceDiscovery(v.ServiceDiscovery); err != nil {
2360			invalidParams.AddNested("ServiceDiscovery", err.(smithy.InvalidParamsError))
2361		}
2362	}
2363	if v.Listeners != nil {
2364		if err := validateListeners(v.Listeners); err != nil {
2365			invalidParams.AddNested("Listeners", err.(smithy.InvalidParamsError))
2366		}
2367	}
2368	if v.Backends != nil {
2369		if err := validateBackends(v.Backends); err != nil {
2370			invalidParams.AddNested("Backends", err.(smithy.InvalidParamsError))
2371		}
2372	}
2373	if v.BackendDefaults != nil {
2374		if err := validateBackendDefaults(v.BackendDefaults); err != nil {
2375			invalidParams.AddNested("BackendDefaults", err.(smithy.InvalidParamsError))
2376		}
2377	}
2378	if v.Logging != nil {
2379		if err := validateLogging(v.Logging); err != nil {
2380			invalidParams.AddNested("Logging", err.(smithy.InvalidParamsError))
2381		}
2382	}
2383	if invalidParams.Len() > 0 {
2384		return invalidParams
2385	} else {
2386		return nil
2387	}
2388}
2389
2390func validateVirtualRouterListener(v *types.VirtualRouterListener) error {
2391	if v == nil {
2392		return nil
2393	}
2394	invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterListener"}
2395	if v.PortMapping == nil {
2396		invalidParams.Add(smithy.NewErrParamRequired("PortMapping"))
2397	} else if v.PortMapping != nil {
2398		if err := validatePortMapping(v.PortMapping); err != nil {
2399			invalidParams.AddNested("PortMapping", err.(smithy.InvalidParamsError))
2400		}
2401	}
2402	if invalidParams.Len() > 0 {
2403		return invalidParams
2404	} else {
2405		return nil
2406	}
2407}
2408
2409func validateVirtualRouterListeners(v []types.VirtualRouterListener) error {
2410	if v == nil {
2411		return nil
2412	}
2413	invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterListeners"}
2414	for i := range v {
2415		if err := validateVirtualRouterListener(&v[i]); err != nil {
2416			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2417		}
2418	}
2419	if invalidParams.Len() > 0 {
2420		return invalidParams
2421	} else {
2422		return nil
2423	}
2424}
2425
2426func validateVirtualRouterServiceProvider(v *types.VirtualRouterServiceProvider) error {
2427	if v == nil {
2428		return nil
2429	}
2430	invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterServiceProvider"}
2431	if v.VirtualRouterName == nil {
2432		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
2433	}
2434	if invalidParams.Len() > 0 {
2435		return invalidParams
2436	} else {
2437		return nil
2438	}
2439}
2440
2441func validateVirtualRouterSpec(v *types.VirtualRouterSpec) error {
2442	if v == nil {
2443		return nil
2444	}
2445	invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterSpec"}
2446	if v.Listeners != nil {
2447		if err := validateVirtualRouterListeners(v.Listeners); err != nil {
2448			invalidParams.AddNested("Listeners", err.(smithy.InvalidParamsError))
2449		}
2450	}
2451	if invalidParams.Len() > 0 {
2452		return invalidParams
2453	} else {
2454		return nil
2455	}
2456}
2457
2458func validateVirtualServiceBackend(v *types.VirtualServiceBackend) error {
2459	if v == nil {
2460		return nil
2461	}
2462	invalidParams := smithy.InvalidParamsError{Context: "VirtualServiceBackend"}
2463	if v.VirtualServiceName == nil {
2464		invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName"))
2465	}
2466	if v.ClientPolicy != nil {
2467		if err := validateClientPolicy(v.ClientPolicy); err != nil {
2468			invalidParams.AddNested("ClientPolicy", err.(smithy.InvalidParamsError))
2469		}
2470	}
2471	if invalidParams.Len() > 0 {
2472		return invalidParams
2473	} else {
2474		return nil
2475	}
2476}
2477
2478func validateVirtualServiceProvider(v types.VirtualServiceProvider) error {
2479	if v == nil {
2480		return nil
2481	}
2482	invalidParams := smithy.InvalidParamsError{Context: "VirtualServiceProvider"}
2483	switch uv := v.(type) {
2484	case *types.VirtualServiceProviderMemberVirtualNode:
2485		if err := validateVirtualNodeServiceProvider(&uv.Value); err != nil {
2486			invalidParams.AddNested("[virtualNode]", err.(smithy.InvalidParamsError))
2487		}
2488
2489	case *types.VirtualServiceProviderMemberVirtualRouter:
2490		if err := validateVirtualRouterServiceProvider(&uv.Value); err != nil {
2491			invalidParams.AddNested("[virtualRouter]", err.(smithy.InvalidParamsError))
2492		}
2493
2494	}
2495	if invalidParams.Len() > 0 {
2496		return invalidParams
2497	} else {
2498		return nil
2499	}
2500}
2501
2502func validateVirtualServiceSpec(v *types.VirtualServiceSpec) error {
2503	if v == nil {
2504		return nil
2505	}
2506	invalidParams := smithy.InvalidParamsError{Context: "VirtualServiceSpec"}
2507	if v.Provider != nil {
2508		if err := validateVirtualServiceProvider(v.Provider); err != nil {
2509			invalidParams.AddNested("Provider", err.(smithy.InvalidParamsError))
2510		}
2511	}
2512	if invalidParams.Len() > 0 {
2513		return invalidParams
2514	} else {
2515		return nil
2516	}
2517}
2518
2519func validateWeightedTarget(v *types.WeightedTarget) error {
2520	if v == nil {
2521		return nil
2522	}
2523	invalidParams := smithy.InvalidParamsError{Context: "WeightedTarget"}
2524	if v.VirtualNode == nil {
2525		invalidParams.Add(smithy.NewErrParamRequired("VirtualNode"))
2526	}
2527	if invalidParams.Len() > 0 {
2528		return invalidParams
2529	} else {
2530		return nil
2531	}
2532}
2533
2534func validateWeightedTargets(v []types.WeightedTarget) error {
2535	if v == nil {
2536		return nil
2537	}
2538	invalidParams := smithy.InvalidParamsError{Context: "WeightedTargets"}
2539	for i := range v {
2540		if err := validateWeightedTarget(&v[i]); err != nil {
2541			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2542		}
2543	}
2544	if invalidParams.Len() > 0 {
2545		return invalidParams
2546	} else {
2547		return nil
2548	}
2549}
2550
2551func validateOpCreateGatewayRouteInput(v *CreateGatewayRouteInput) error {
2552	if v == nil {
2553		return nil
2554	}
2555	invalidParams := smithy.InvalidParamsError{Context: "CreateGatewayRouteInput"}
2556	if v.GatewayRouteName == nil {
2557		invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName"))
2558	}
2559	if v.MeshName == nil {
2560		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2561	}
2562	if v.VirtualGatewayName == nil {
2563		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
2564	}
2565	if v.Spec == nil {
2566		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
2567	} else if v.Spec != nil {
2568		if err := validateGatewayRouteSpec(v.Spec); err != nil {
2569			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
2570		}
2571	}
2572	if v.Tags != nil {
2573		if err := validateTagList(v.Tags); err != nil {
2574			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2575		}
2576	}
2577	if invalidParams.Len() > 0 {
2578		return invalidParams
2579	} else {
2580		return nil
2581	}
2582}
2583
2584func validateOpCreateMeshInput(v *CreateMeshInput) error {
2585	if v == nil {
2586		return nil
2587	}
2588	invalidParams := smithy.InvalidParamsError{Context: "CreateMeshInput"}
2589	if v.MeshName == nil {
2590		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2591	}
2592	if v.Spec != nil {
2593		if err := validateMeshSpec(v.Spec); err != nil {
2594			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
2595		}
2596	}
2597	if v.Tags != nil {
2598		if err := validateTagList(v.Tags); err != nil {
2599			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2600		}
2601	}
2602	if invalidParams.Len() > 0 {
2603		return invalidParams
2604	} else {
2605		return nil
2606	}
2607}
2608
2609func validateOpCreateRouteInput(v *CreateRouteInput) error {
2610	if v == nil {
2611		return nil
2612	}
2613	invalidParams := smithy.InvalidParamsError{Context: "CreateRouteInput"}
2614	if v.RouteName == nil {
2615		invalidParams.Add(smithy.NewErrParamRequired("RouteName"))
2616	}
2617	if v.MeshName == nil {
2618		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2619	}
2620	if v.VirtualRouterName == nil {
2621		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
2622	}
2623	if v.Spec == nil {
2624		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
2625	} else if v.Spec != nil {
2626		if err := validateRouteSpec(v.Spec); err != nil {
2627			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
2628		}
2629	}
2630	if v.Tags != nil {
2631		if err := validateTagList(v.Tags); err != nil {
2632			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2633		}
2634	}
2635	if invalidParams.Len() > 0 {
2636		return invalidParams
2637	} else {
2638		return nil
2639	}
2640}
2641
2642func validateOpCreateVirtualGatewayInput(v *CreateVirtualGatewayInput) error {
2643	if v == nil {
2644		return nil
2645	}
2646	invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualGatewayInput"}
2647	if v.VirtualGatewayName == nil {
2648		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
2649	}
2650	if v.MeshName == nil {
2651		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2652	}
2653	if v.Spec == nil {
2654		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
2655	} else if v.Spec != nil {
2656		if err := validateVirtualGatewaySpec(v.Spec); err != nil {
2657			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
2658		}
2659	}
2660	if v.Tags != nil {
2661		if err := validateTagList(v.Tags); err != nil {
2662			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2663		}
2664	}
2665	if invalidParams.Len() > 0 {
2666		return invalidParams
2667	} else {
2668		return nil
2669	}
2670}
2671
2672func validateOpCreateVirtualNodeInput(v *CreateVirtualNodeInput) error {
2673	if v == nil {
2674		return nil
2675	}
2676	invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualNodeInput"}
2677	if v.VirtualNodeName == nil {
2678		invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName"))
2679	}
2680	if v.MeshName == nil {
2681		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2682	}
2683	if v.Spec == nil {
2684		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
2685	} else if v.Spec != nil {
2686		if err := validateVirtualNodeSpec(v.Spec); err != nil {
2687			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
2688		}
2689	}
2690	if v.Tags != nil {
2691		if err := validateTagList(v.Tags); err != nil {
2692			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2693		}
2694	}
2695	if invalidParams.Len() > 0 {
2696		return invalidParams
2697	} else {
2698		return nil
2699	}
2700}
2701
2702func validateOpCreateVirtualRouterInput(v *CreateVirtualRouterInput) error {
2703	if v == nil {
2704		return nil
2705	}
2706	invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualRouterInput"}
2707	if v.VirtualRouterName == nil {
2708		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
2709	}
2710	if v.MeshName == nil {
2711		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2712	}
2713	if v.Spec == nil {
2714		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
2715	} else if v.Spec != nil {
2716		if err := validateVirtualRouterSpec(v.Spec); err != nil {
2717			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
2718		}
2719	}
2720	if v.Tags != nil {
2721		if err := validateTagList(v.Tags); err != nil {
2722			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2723		}
2724	}
2725	if invalidParams.Len() > 0 {
2726		return invalidParams
2727	} else {
2728		return nil
2729	}
2730}
2731
2732func validateOpCreateVirtualServiceInput(v *CreateVirtualServiceInput) error {
2733	if v == nil {
2734		return nil
2735	}
2736	invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualServiceInput"}
2737	if v.VirtualServiceName == nil {
2738		invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName"))
2739	}
2740	if v.MeshName == nil {
2741		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2742	}
2743	if v.Spec == nil {
2744		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
2745	} else if v.Spec != nil {
2746		if err := validateVirtualServiceSpec(v.Spec); err != nil {
2747			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
2748		}
2749	}
2750	if v.Tags != nil {
2751		if err := validateTagList(v.Tags); err != nil {
2752			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2753		}
2754	}
2755	if invalidParams.Len() > 0 {
2756		return invalidParams
2757	} else {
2758		return nil
2759	}
2760}
2761
2762func validateOpDeleteGatewayRouteInput(v *DeleteGatewayRouteInput) error {
2763	if v == nil {
2764		return nil
2765	}
2766	invalidParams := smithy.InvalidParamsError{Context: "DeleteGatewayRouteInput"}
2767	if v.GatewayRouteName == nil {
2768		invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName"))
2769	}
2770	if v.MeshName == nil {
2771		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2772	}
2773	if v.VirtualGatewayName == nil {
2774		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
2775	}
2776	if invalidParams.Len() > 0 {
2777		return invalidParams
2778	} else {
2779		return nil
2780	}
2781}
2782
2783func validateOpDeleteMeshInput(v *DeleteMeshInput) error {
2784	if v == nil {
2785		return nil
2786	}
2787	invalidParams := smithy.InvalidParamsError{Context: "DeleteMeshInput"}
2788	if v.MeshName == nil {
2789		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2790	}
2791	if invalidParams.Len() > 0 {
2792		return invalidParams
2793	} else {
2794		return nil
2795	}
2796}
2797
2798func validateOpDeleteRouteInput(v *DeleteRouteInput) error {
2799	if v == nil {
2800		return nil
2801	}
2802	invalidParams := smithy.InvalidParamsError{Context: "DeleteRouteInput"}
2803	if v.RouteName == nil {
2804		invalidParams.Add(smithy.NewErrParamRequired("RouteName"))
2805	}
2806	if v.MeshName == nil {
2807		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2808	}
2809	if v.VirtualRouterName == nil {
2810		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
2811	}
2812	if invalidParams.Len() > 0 {
2813		return invalidParams
2814	} else {
2815		return nil
2816	}
2817}
2818
2819func validateOpDeleteVirtualGatewayInput(v *DeleteVirtualGatewayInput) error {
2820	if v == nil {
2821		return nil
2822	}
2823	invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualGatewayInput"}
2824	if v.VirtualGatewayName == nil {
2825		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
2826	}
2827	if v.MeshName == nil {
2828		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2829	}
2830	if invalidParams.Len() > 0 {
2831		return invalidParams
2832	} else {
2833		return nil
2834	}
2835}
2836
2837func validateOpDeleteVirtualNodeInput(v *DeleteVirtualNodeInput) error {
2838	if v == nil {
2839		return nil
2840	}
2841	invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualNodeInput"}
2842	if v.VirtualNodeName == nil {
2843		invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName"))
2844	}
2845	if v.MeshName == nil {
2846		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2847	}
2848	if invalidParams.Len() > 0 {
2849		return invalidParams
2850	} else {
2851		return nil
2852	}
2853}
2854
2855func validateOpDeleteVirtualRouterInput(v *DeleteVirtualRouterInput) error {
2856	if v == nil {
2857		return nil
2858	}
2859	invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualRouterInput"}
2860	if v.VirtualRouterName == nil {
2861		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
2862	}
2863	if v.MeshName == nil {
2864		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2865	}
2866	if invalidParams.Len() > 0 {
2867		return invalidParams
2868	} else {
2869		return nil
2870	}
2871}
2872
2873func validateOpDeleteVirtualServiceInput(v *DeleteVirtualServiceInput) error {
2874	if v == nil {
2875		return nil
2876	}
2877	invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualServiceInput"}
2878	if v.VirtualServiceName == nil {
2879		invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName"))
2880	}
2881	if v.MeshName == nil {
2882		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2883	}
2884	if invalidParams.Len() > 0 {
2885		return invalidParams
2886	} else {
2887		return nil
2888	}
2889}
2890
2891func validateOpDescribeGatewayRouteInput(v *DescribeGatewayRouteInput) error {
2892	if v == nil {
2893		return nil
2894	}
2895	invalidParams := smithy.InvalidParamsError{Context: "DescribeGatewayRouteInput"}
2896	if v.GatewayRouteName == nil {
2897		invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName"))
2898	}
2899	if v.MeshName == nil {
2900		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2901	}
2902	if v.VirtualGatewayName == nil {
2903		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
2904	}
2905	if invalidParams.Len() > 0 {
2906		return invalidParams
2907	} else {
2908		return nil
2909	}
2910}
2911
2912func validateOpDescribeMeshInput(v *DescribeMeshInput) error {
2913	if v == nil {
2914		return nil
2915	}
2916	invalidParams := smithy.InvalidParamsError{Context: "DescribeMeshInput"}
2917	if v.MeshName == nil {
2918		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2919	}
2920	if invalidParams.Len() > 0 {
2921		return invalidParams
2922	} else {
2923		return nil
2924	}
2925}
2926
2927func validateOpDescribeRouteInput(v *DescribeRouteInput) error {
2928	if v == nil {
2929		return nil
2930	}
2931	invalidParams := smithy.InvalidParamsError{Context: "DescribeRouteInput"}
2932	if v.RouteName == nil {
2933		invalidParams.Add(smithy.NewErrParamRequired("RouteName"))
2934	}
2935	if v.MeshName == nil {
2936		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2937	}
2938	if v.VirtualRouterName == nil {
2939		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
2940	}
2941	if invalidParams.Len() > 0 {
2942		return invalidParams
2943	} else {
2944		return nil
2945	}
2946}
2947
2948func validateOpDescribeVirtualGatewayInput(v *DescribeVirtualGatewayInput) error {
2949	if v == nil {
2950		return nil
2951	}
2952	invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualGatewayInput"}
2953	if v.VirtualGatewayName == nil {
2954		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
2955	}
2956	if v.MeshName == nil {
2957		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2958	}
2959	if invalidParams.Len() > 0 {
2960		return invalidParams
2961	} else {
2962		return nil
2963	}
2964}
2965
2966func validateOpDescribeVirtualNodeInput(v *DescribeVirtualNodeInput) error {
2967	if v == nil {
2968		return nil
2969	}
2970	invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualNodeInput"}
2971	if v.VirtualNodeName == nil {
2972		invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName"))
2973	}
2974	if v.MeshName == nil {
2975		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2976	}
2977	if invalidParams.Len() > 0 {
2978		return invalidParams
2979	} else {
2980		return nil
2981	}
2982}
2983
2984func validateOpDescribeVirtualRouterInput(v *DescribeVirtualRouterInput) error {
2985	if v == nil {
2986		return nil
2987	}
2988	invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualRouterInput"}
2989	if v.VirtualRouterName == nil {
2990		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
2991	}
2992	if v.MeshName == nil {
2993		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
2994	}
2995	if invalidParams.Len() > 0 {
2996		return invalidParams
2997	} else {
2998		return nil
2999	}
3000}
3001
3002func validateOpDescribeVirtualServiceInput(v *DescribeVirtualServiceInput) error {
3003	if v == nil {
3004		return nil
3005	}
3006	invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualServiceInput"}
3007	if v.VirtualServiceName == nil {
3008		invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName"))
3009	}
3010	if v.MeshName == nil {
3011		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3012	}
3013	if invalidParams.Len() > 0 {
3014		return invalidParams
3015	} else {
3016		return nil
3017	}
3018}
3019
3020func validateOpListGatewayRoutesInput(v *ListGatewayRoutesInput) error {
3021	if v == nil {
3022		return nil
3023	}
3024	invalidParams := smithy.InvalidParamsError{Context: "ListGatewayRoutesInput"}
3025	if v.MeshName == nil {
3026		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3027	}
3028	if v.VirtualGatewayName == nil {
3029		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
3030	}
3031	if invalidParams.Len() > 0 {
3032		return invalidParams
3033	} else {
3034		return nil
3035	}
3036}
3037
3038func validateOpListRoutesInput(v *ListRoutesInput) error {
3039	if v == nil {
3040		return nil
3041	}
3042	invalidParams := smithy.InvalidParamsError{Context: "ListRoutesInput"}
3043	if v.MeshName == nil {
3044		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3045	}
3046	if v.VirtualRouterName == nil {
3047		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
3048	}
3049	if invalidParams.Len() > 0 {
3050		return invalidParams
3051	} else {
3052		return nil
3053	}
3054}
3055
3056func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
3057	if v == nil {
3058		return nil
3059	}
3060	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
3061	if v.ResourceArn == nil {
3062		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
3063	}
3064	if invalidParams.Len() > 0 {
3065		return invalidParams
3066	} else {
3067		return nil
3068	}
3069}
3070
3071func validateOpListVirtualGatewaysInput(v *ListVirtualGatewaysInput) error {
3072	if v == nil {
3073		return nil
3074	}
3075	invalidParams := smithy.InvalidParamsError{Context: "ListVirtualGatewaysInput"}
3076	if v.MeshName == nil {
3077		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3078	}
3079	if invalidParams.Len() > 0 {
3080		return invalidParams
3081	} else {
3082		return nil
3083	}
3084}
3085
3086func validateOpListVirtualNodesInput(v *ListVirtualNodesInput) error {
3087	if v == nil {
3088		return nil
3089	}
3090	invalidParams := smithy.InvalidParamsError{Context: "ListVirtualNodesInput"}
3091	if v.MeshName == nil {
3092		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3093	}
3094	if invalidParams.Len() > 0 {
3095		return invalidParams
3096	} else {
3097		return nil
3098	}
3099}
3100
3101func validateOpListVirtualRoutersInput(v *ListVirtualRoutersInput) error {
3102	if v == nil {
3103		return nil
3104	}
3105	invalidParams := smithy.InvalidParamsError{Context: "ListVirtualRoutersInput"}
3106	if v.MeshName == nil {
3107		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3108	}
3109	if invalidParams.Len() > 0 {
3110		return invalidParams
3111	} else {
3112		return nil
3113	}
3114}
3115
3116func validateOpListVirtualServicesInput(v *ListVirtualServicesInput) error {
3117	if v == nil {
3118		return nil
3119	}
3120	invalidParams := smithy.InvalidParamsError{Context: "ListVirtualServicesInput"}
3121	if v.MeshName == nil {
3122		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3123	}
3124	if invalidParams.Len() > 0 {
3125		return invalidParams
3126	} else {
3127		return nil
3128	}
3129}
3130
3131func validateOpTagResourceInput(v *TagResourceInput) error {
3132	if v == nil {
3133		return nil
3134	}
3135	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
3136	if v.ResourceArn == nil {
3137		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
3138	}
3139	if v.Tags == nil {
3140		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
3141	} else if v.Tags != nil {
3142		if err := validateTagList(v.Tags); err != nil {
3143			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
3144		}
3145	}
3146	if invalidParams.Len() > 0 {
3147		return invalidParams
3148	} else {
3149		return nil
3150	}
3151}
3152
3153func validateOpUntagResourceInput(v *UntagResourceInput) error {
3154	if v == nil {
3155		return nil
3156	}
3157	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
3158	if v.ResourceArn == nil {
3159		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
3160	}
3161	if v.TagKeys == nil {
3162		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
3163	}
3164	if invalidParams.Len() > 0 {
3165		return invalidParams
3166	} else {
3167		return nil
3168	}
3169}
3170
3171func validateOpUpdateGatewayRouteInput(v *UpdateGatewayRouteInput) error {
3172	if v == nil {
3173		return nil
3174	}
3175	invalidParams := smithy.InvalidParamsError{Context: "UpdateGatewayRouteInput"}
3176	if v.GatewayRouteName == nil {
3177		invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName"))
3178	}
3179	if v.MeshName == nil {
3180		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3181	}
3182	if v.VirtualGatewayName == nil {
3183		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
3184	}
3185	if v.Spec == nil {
3186		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3187	} else if v.Spec != nil {
3188		if err := validateGatewayRouteSpec(v.Spec); err != nil {
3189			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3190		}
3191	}
3192	if invalidParams.Len() > 0 {
3193		return invalidParams
3194	} else {
3195		return nil
3196	}
3197}
3198
3199func validateOpUpdateMeshInput(v *UpdateMeshInput) error {
3200	if v == nil {
3201		return nil
3202	}
3203	invalidParams := smithy.InvalidParamsError{Context: "UpdateMeshInput"}
3204	if v.MeshName == nil {
3205		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3206	}
3207	if v.Spec != nil {
3208		if err := validateMeshSpec(v.Spec); err != nil {
3209			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3210		}
3211	}
3212	if invalidParams.Len() > 0 {
3213		return invalidParams
3214	} else {
3215		return nil
3216	}
3217}
3218
3219func validateOpUpdateRouteInput(v *UpdateRouteInput) error {
3220	if v == nil {
3221		return nil
3222	}
3223	invalidParams := smithy.InvalidParamsError{Context: "UpdateRouteInput"}
3224	if v.RouteName == nil {
3225		invalidParams.Add(smithy.NewErrParamRequired("RouteName"))
3226	}
3227	if v.MeshName == nil {
3228		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3229	}
3230	if v.VirtualRouterName == nil {
3231		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
3232	}
3233	if v.Spec == nil {
3234		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3235	} else if v.Spec != nil {
3236		if err := validateRouteSpec(v.Spec); err != nil {
3237			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3238		}
3239	}
3240	if invalidParams.Len() > 0 {
3241		return invalidParams
3242	} else {
3243		return nil
3244	}
3245}
3246
3247func validateOpUpdateVirtualGatewayInput(v *UpdateVirtualGatewayInput) error {
3248	if v == nil {
3249		return nil
3250	}
3251	invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualGatewayInput"}
3252	if v.VirtualGatewayName == nil {
3253		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
3254	}
3255	if v.MeshName == nil {
3256		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3257	}
3258	if v.Spec == nil {
3259		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3260	} else if v.Spec != nil {
3261		if err := validateVirtualGatewaySpec(v.Spec); err != nil {
3262			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3263		}
3264	}
3265	if invalidParams.Len() > 0 {
3266		return invalidParams
3267	} else {
3268		return nil
3269	}
3270}
3271
3272func validateOpUpdateVirtualNodeInput(v *UpdateVirtualNodeInput) error {
3273	if v == nil {
3274		return nil
3275	}
3276	invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualNodeInput"}
3277	if v.VirtualNodeName == nil {
3278		invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName"))
3279	}
3280	if v.MeshName == nil {
3281		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3282	}
3283	if v.Spec == nil {
3284		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3285	} else if v.Spec != nil {
3286		if err := validateVirtualNodeSpec(v.Spec); err != nil {
3287			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3288		}
3289	}
3290	if invalidParams.Len() > 0 {
3291		return invalidParams
3292	} else {
3293		return nil
3294	}
3295}
3296
3297func validateOpUpdateVirtualRouterInput(v *UpdateVirtualRouterInput) error {
3298	if v == nil {
3299		return nil
3300	}
3301	invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualRouterInput"}
3302	if v.VirtualRouterName == nil {
3303		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
3304	}
3305	if v.MeshName == nil {
3306		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3307	}
3308	if v.Spec == nil {
3309		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3310	} else if v.Spec != nil {
3311		if err := validateVirtualRouterSpec(v.Spec); err != nil {
3312			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3313		}
3314	}
3315	if invalidParams.Len() > 0 {
3316		return invalidParams
3317	} else {
3318		return nil
3319	}
3320}
3321
3322func validateOpUpdateVirtualServiceInput(v *UpdateVirtualServiceInput) error {
3323	if v == nil {
3324		return nil
3325	}
3326	invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualServiceInput"}
3327	if v.VirtualServiceName == nil {
3328		invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName"))
3329	}
3330	if v.MeshName == nil {
3331		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3332	}
3333	if v.Spec == nil {
3334		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3335	} else if v.Spec != nil {
3336		if err := validateVirtualServiceSpec(v.Spec); err != nil {
3337			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3338		}
3339	}
3340	if invalidParams.Len() > 0 {
3341		return invalidParams
3342	} else {
3343		return nil
3344	}
3345}
3346