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.Certificate != nil {
1054		if err := validateClientTlsCertificate(v.Certificate); err != nil {
1055			invalidParams.AddNested("Certificate", err.(smithy.InvalidParamsError))
1056		}
1057	}
1058	if v.Validation == nil {
1059		invalidParams.Add(smithy.NewErrParamRequired("Validation"))
1060	} else if v.Validation != nil {
1061		if err := validateTlsValidationContext(v.Validation); err != nil {
1062			invalidParams.AddNested("Validation", err.(smithy.InvalidParamsError))
1063		}
1064	}
1065	if invalidParams.Len() > 0 {
1066		return invalidParams
1067	} else {
1068		return nil
1069	}
1070}
1071
1072func validateClientTlsCertificate(v types.ClientTlsCertificate) error {
1073	if v == nil {
1074		return nil
1075	}
1076	invalidParams := smithy.InvalidParamsError{Context: "ClientTlsCertificate"}
1077	switch uv := v.(type) {
1078	case *types.ClientTlsCertificateMemberFile:
1079		if err := validateListenerTlsFileCertificate(&uv.Value); err != nil {
1080			invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError))
1081		}
1082
1083	case *types.ClientTlsCertificateMemberSds:
1084		if err := validateListenerTlsSdsCertificate(&uv.Value); err != nil {
1085			invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError))
1086		}
1087
1088	}
1089	if invalidParams.Len() > 0 {
1090		return invalidParams
1091	} else {
1092		return nil
1093	}
1094}
1095
1096func validateDnsServiceDiscovery(v *types.DnsServiceDiscovery) error {
1097	if v == nil {
1098		return nil
1099	}
1100	invalidParams := smithy.InvalidParamsError{Context: "DnsServiceDiscovery"}
1101	if v.Hostname == nil {
1102		invalidParams.Add(smithy.NewErrParamRequired("Hostname"))
1103	}
1104	if invalidParams.Len() > 0 {
1105		return invalidParams
1106	} else {
1107		return nil
1108	}
1109}
1110
1111func validateEgressFilter(v *types.EgressFilter) error {
1112	if v == nil {
1113		return nil
1114	}
1115	invalidParams := smithy.InvalidParamsError{Context: "EgressFilter"}
1116	if len(v.Type) == 0 {
1117		invalidParams.Add(smithy.NewErrParamRequired("Type"))
1118	}
1119	if invalidParams.Len() > 0 {
1120		return invalidParams
1121	} else {
1122		return nil
1123	}
1124}
1125
1126func validateFileAccessLog(v *types.FileAccessLog) error {
1127	if v == nil {
1128		return nil
1129	}
1130	invalidParams := smithy.InvalidParamsError{Context: "FileAccessLog"}
1131	if v.Path == nil {
1132		invalidParams.Add(smithy.NewErrParamRequired("Path"))
1133	}
1134	if invalidParams.Len() > 0 {
1135		return invalidParams
1136	} else {
1137		return nil
1138	}
1139}
1140
1141func validateGatewayRouteSpec(v *types.GatewayRouteSpec) error {
1142	if v == nil {
1143		return nil
1144	}
1145	invalidParams := smithy.InvalidParamsError{Context: "GatewayRouteSpec"}
1146	if v.HttpRoute != nil {
1147		if err := validateHttpGatewayRoute(v.HttpRoute); err != nil {
1148			invalidParams.AddNested("HttpRoute", err.(smithy.InvalidParamsError))
1149		}
1150	}
1151	if v.Http2Route != nil {
1152		if err := validateHttpGatewayRoute(v.Http2Route); err != nil {
1153			invalidParams.AddNested("Http2Route", err.(smithy.InvalidParamsError))
1154		}
1155	}
1156	if v.GrpcRoute != nil {
1157		if err := validateGrpcGatewayRoute(v.GrpcRoute); err != nil {
1158			invalidParams.AddNested("GrpcRoute", err.(smithy.InvalidParamsError))
1159		}
1160	}
1161	if invalidParams.Len() > 0 {
1162		return invalidParams
1163	} else {
1164		return nil
1165	}
1166}
1167
1168func validateGatewayRouteTarget(v *types.GatewayRouteTarget) error {
1169	if v == nil {
1170		return nil
1171	}
1172	invalidParams := smithy.InvalidParamsError{Context: "GatewayRouteTarget"}
1173	if v.VirtualService == nil {
1174		invalidParams.Add(smithy.NewErrParamRequired("VirtualService"))
1175	} else if v.VirtualService != nil {
1176		if err := validateGatewayRouteVirtualService(v.VirtualService); err != nil {
1177			invalidParams.AddNested("VirtualService", err.(smithy.InvalidParamsError))
1178		}
1179	}
1180	if invalidParams.Len() > 0 {
1181		return invalidParams
1182	} else {
1183		return nil
1184	}
1185}
1186
1187func validateGatewayRouteVirtualService(v *types.GatewayRouteVirtualService) error {
1188	if v == nil {
1189		return nil
1190	}
1191	invalidParams := smithy.InvalidParamsError{Context: "GatewayRouteVirtualService"}
1192	if v.VirtualServiceName == nil {
1193		invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName"))
1194	}
1195	if invalidParams.Len() > 0 {
1196		return invalidParams
1197	} else {
1198		return nil
1199	}
1200}
1201
1202func validateGrpcGatewayRoute(v *types.GrpcGatewayRoute) error {
1203	if v == nil {
1204		return nil
1205	}
1206	invalidParams := smithy.InvalidParamsError{Context: "GrpcGatewayRoute"}
1207	if v.Match == nil {
1208		invalidParams.Add(smithy.NewErrParamRequired("Match"))
1209	} else if v.Match != nil {
1210		if err := validateGrpcGatewayRouteMatch(v.Match); err != nil {
1211			invalidParams.AddNested("Match", err.(smithy.InvalidParamsError))
1212		}
1213	}
1214	if v.Action == nil {
1215		invalidParams.Add(smithy.NewErrParamRequired("Action"))
1216	} else if v.Action != nil {
1217		if err := validateGrpcGatewayRouteAction(v.Action); err != nil {
1218			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
1219		}
1220	}
1221	if invalidParams.Len() > 0 {
1222		return invalidParams
1223	} else {
1224		return nil
1225	}
1226}
1227
1228func validateGrpcGatewayRouteAction(v *types.GrpcGatewayRouteAction) error {
1229	if v == nil {
1230		return nil
1231	}
1232	invalidParams := smithy.InvalidParamsError{Context: "GrpcGatewayRouteAction"}
1233	if v.Target == nil {
1234		invalidParams.Add(smithy.NewErrParamRequired("Target"))
1235	} else if v.Target != nil {
1236		if err := validateGatewayRouteTarget(v.Target); err != nil {
1237			invalidParams.AddNested("Target", err.(smithy.InvalidParamsError))
1238		}
1239	}
1240	if invalidParams.Len() > 0 {
1241		return invalidParams
1242	} else {
1243		return nil
1244	}
1245}
1246
1247func validateGrpcGatewayRouteMatch(v *types.GrpcGatewayRouteMatch) error {
1248	if v == nil {
1249		return nil
1250	}
1251	invalidParams := smithy.InvalidParamsError{Context: "GrpcGatewayRouteMatch"}
1252	if v.Metadata != nil {
1253		if err := validateGrpcGatewayRouteMetadataList(v.Metadata); err != nil {
1254			invalidParams.AddNested("Metadata", err.(smithy.InvalidParamsError))
1255		}
1256	}
1257	if invalidParams.Len() > 0 {
1258		return invalidParams
1259	} else {
1260		return nil
1261	}
1262}
1263
1264func validateGrpcGatewayRouteMetadata(v *types.GrpcGatewayRouteMetadata) error {
1265	if v == nil {
1266		return nil
1267	}
1268	invalidParams := smithy.InvalidParamsError{Context: "GrpcGatewayRouteMetadata"}
1269	if v.Name == nil {
1270		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1271	}
1272	if v.Match != nil {
1273		if err := validateGrpcMetadataMatchMethod(v.Match); err != nil {
1274			invalidParams.AddNested("Match", err.(smithy.InvalidParamsError))
1275		}
1276	}
1277	if invalidParams.Len() > 0 {
1278		return invalidParams
1279	} else {
1280		return nil
1281	}
1282}
1283
1284func validateGrpcGatewayRouteMetadataList(v []types.GrpcGatewayRouteMetadata) error {
1285	if v == nil {
1286		return nil
1287	}
1288	invalidParams := smithy.InvalidParamsError{Context: "GrpcGatewayRouteMetadataList"}
1289	for i := range v {
1290		if err := validateGrpcGatewayRouteMetadata(&v[i]); err != nil {
1291			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1292		}
1293	}
1294	if invalidParams.Len() > 0 {
1295		return invalidParams
1296	} else {
1297		return nil
1298	}
1299}
1300
1301func validateGrpcMetadataMatchMethod(v types.GrpcMetadataMatchMethod) error {
1302	if v == nil {
1303		return nil
1304	}
1305	invalidParams := smithy.InvalidParamsError{Context: "GrpcMetadataMatchMethod"}
1306	switch uv := v.(type) {
1307	case *types.GrpcMetadataMatchMethodMemberRange:
1308		if err := validateMatchRange(&uv.Value); err != nil {
1309			invalidParams.AddNested("[range]", err.(smithy.InvalidParamsError))
1310		}
1311
1312	}
1313	if invalidParams.Len() > 0 {
1314		return invalidParams
1315	} else {
1316		return nil
1317	}
1318}
1319
1320func validateGrpcRetryPolicy(v *types.GrpcRetryPolicy) error {
1321	if v == nil {
1322		return nil
1323	}
1324	invalidParams := smithy.InvalidParamsError{Context: "GrpcRetryPolicy"}
1325	if v.PerRetryTimeout == nil {
1326		invalidParams.Add(smithy.NewErrParamRequired("PerRetryTimeout"))
1327	}
1328	if v.MaxRetries == nil {
1329		invalidParams.Add(smithy.NewErrParamRequired("MaxRetries"))
1330	}
1331	if invalidParams.Len() > 0 {
1332		return invalidParams
1333	} else {
1334		return nil
1335	}
1336}
1337
1338func validateGrpcRoute(v *types.GrpcRoute) error {
1339	if v == nil {
1340		return nil
1341	}
1342	invalidParams := smithy.InvalidParamsError{Context: "GrpcRoute"}
1343	if v.Action == nil {
1344		invalidParams.Add(smithy.NewErrParamRequired("Action"))
1345	} else if v.Action != nil {
1346		if err := validateGrpcRouteAction(v.Action); err != nil {
1347			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
1348		}
1349	}
1350	if v.Match == nil {
1351		invalidParams.Add(smithy.NewErrParamRequired("Match"))
1352	} else if v.Match != nil {
1353		if err := validateGrpcRouteMatch(v.Match); err != nil {
1354			invalidParams.AddNested("Match", err.(smithy.InvalidParamsError))
1355		}
1356	}
1357	if v.RetryPolicy != nil {
1358		if err := validateGrpcRetryPolicy(v.RetryPolicy); err != nil {
1359			invalidParams.AddNested("RetryPolicy", err.(smithy.InvalidParamsError))
1360		}
1361	}
1362	if invalidParams.Len() > 0 {
1363		return invalidParams
1364	} else {
1365		return nil
1366	}
1367}
1368
1369func validateGrpcRouteAction(v *types.GrpcRouteAction) error {
1370	if v == nil {
1371		return nil
1372	}
1373	invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteAction"}
1374	if v.WeightedTargets == nil {
1375		invalidParams.Add(smithy.NewErrParamRequired("WeightedTargets"))
1376	} else if v.WeightedTargets != nil {
1377		if err := validateWeightedTargets(v.WeightedTargets); err != nil {
1378			invalidParams.AddNested("WeightedTargets", err.(smithy.InvalidParamsError))
1379		}
1380	}
1381	if invalidParams.Len() > 0 {
1382		return invalidParams
1383	} else {
1384		return nil
1385	}
1386}
1387
1388func validateGrpcRouteMatch(v *types.GrpcRouteMatch) error {
1389	if v == nil {
1390		return nil
1391	}
1392	invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMatch"}
1393	if v.Metadata != nil {
1394		if err := validateGrpcRouteMetadataList(v.Metadata); err != nil {
1395			invalidParams.AddNested("Metadata", err.(smithy.InvalidParamsError))
1396		}
1397	}
1398	if invalidParams.Len() > 0 {
1399		return invalidParams
1400	} else {
1401		return nil
1402	}
1403}
1404
1405func validateGrpcRouteMetadata(v *types.GrpcRouteMetadata) error {
1406	if v == nil {
1407		return nil
1408	}
1409	invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMetadata"}
1410	if v.Name == nil {
1411		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1412	}
1413	if v.Match != nil {
1414		if err := validateGrpcRouteMetadataMatchMethod(v.Match); err != nil {
1415			invalidParams.AddNested("Match", err.(smithy.InvalidParamsError))
1416		}
1417	}
1418	if invalidParams.Len() > 0 {
1419		return invalidParams
1420	} else {
1421		return nil
1422	}
1423}
1424
1425func validateGrpcRouteMetadataList(v []types.GrpcRouteMetadata) error {
1426	if v == nil {
1427		return nil
1428	}
1429	invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMetadataList"}
1430	for i := range v {
1431		if err := validateGrpcRouteMetadata(&v[i]); err != nil {
1432			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1433		}
1434	}
1435	if invalidParams.Len() > 0 {
1436		return invalidParams
1437	} else {
1438		return nil
1439	}
1440}
1441
1442func validateGrpcRouteMetadataMatchMethod(v types.GrpcRouteMetadataMatchMethod) error {
1443	if v == nil {
1444		return nil
1445	}
1446	invalidParams := smithy.InvalidParamsError{Context: "GrpcRouteMetadataMatchMethod"}
1447	switch uv := v.(type) {
1448	case *types.GrpcRouteMetadataMatchMethodMemberRange:
1449		if err := validateMatchRange(&uv.Value); err != nil {
1450			invalidParams.AddNested("[range]", err.(smithy.InvalidParamsError))
1451		}
1452
1453	}
1454	if invalidParams.Len() > 0 {
1455		return invalidParams
1456	} else {
1457		return nil
1458	}
1459}
1460
1461func validateHeaderMatchMethod(v types.HeaderMatchMethod) error {
1462	if v == nil {
1463		return nil
1464	}
1465	invalidParams := smithy.InvalidParamsError{Context: "HeaderMatchMethod"}
1466	switch uv := v.(type) {
1467	case *types.HeaderMatchMethodMemberRange:
1468		if err := validateMatchRange(&uv.Value); err != nil {
1469			invalidParams.AddNested("[range]", err.(smithy.InvalidParamsError))
1470		}
1471
1472	}
1473	if invalidParams.Len() > 0 {
1474		return invalidParams
1475	} else {
1476		return nil
1477	}
1478}
1479
1480func validateHealthCheckPolicy(v *types.HealthCheckPolicy) error {
1481	if v == nil {
1482		return nil
1483	}
1484	invalidParams := smithy.InvalidParamsError{Context: "HealthCheckPolicy"}
1485	if v.TimeoutMillis == nil {
1486		invalidParams.Add(smithy.NewErrParamRequired("TimeoutMillis"))
1487	}
1488	if v.IntervalMillis == nil {
1489		invalidParams.Add(smithy.NewErrParamRequired("IntervalMillis"))
1490	}
1491	if len(v.Protocol) == 0 {
1492		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
1493	}
1494	if invalidParams.Len() > 0 {
1495		return invalidParams
1496	} else {
1497		return nil
1498	}
1499}
1500
1501func validateHttpGatewayRoute(v *types.HttpGatewayRoute) error {
1502	if v == nil {
1503		return nil
1504	}
1505	invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRoute"}
1506	if v.Match == nil {
1507		invalidParams.Add(smithy.NewErrParamRequired("Match"))
1508	} else if v.Match != nil {
1509		if err := validateHttpGatewayRouteMatch(v.Match); err != nil {
1510			invalidParams.AddNested("Match", err.(smithy.InvalidParamsError))
1511		}
1512	}
1513	if v.Action == nil {
1514		invalidParams.Add(smithy.NewErrParamRequired("Action"))
1515	} else if v.Action != nil {
1516		if err := validateHttpGatewayRouteAction(v.Action); err != nil {
1517			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
1518		}
1519	}
1520	if invalidParams.Len() > 0 {
1521		return invalidParams
1522	} else {
1523		return nil
1524	}
1525}
1526
1527func validateHttpGatewayRouteAction(v *types.HttpGatewayRouteAction) error {
1528	if v == nil {
1529		return nil
1530	}
1531	invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRouteAction"}
1532	if v.Target == nil {
1533		invalidParams.Add(smithy.NewErrParamRequired("Target"))
1534	} else if v.Target != nil {
1535		if err := validateGatewayRouteTarget(v.Target); err != nil {
1536			invalidParams.AddNested("Target", err.(smithy.InvalidParamsError))
1537		}
1538	}
1539	if invalidParams.Len() > 0 {
1540		return invalidParams
1541	} else {
1542		return nil
1543	}
1544}
1545
1546func validateHttpGatewayRouteHeader(v *types.HttpGatewayRouteHeader) error {
1547	if v == nil {
1548		return nil
1549	}
1550	invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRouteHeader"}
1551	if v.Name == nil {
1552		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1553	}
1554	if v.Match != nil {
1555		if err := validateHeaderMatchMethod(v.Match); err != nil {
1556			invalidParams.AddNested("Match", err.(smithy.InvalidParamsError))
1557		}
1558	}
1559	if invalidParams.Len() > 0 {
1560		return invalidParams
1561	} else {
1562		return nil
1563	}
1564}
1565
1566func validateHttpGatewayRouteHeaders(v []types.HttpGatewayRouteHeader) error {
1567	if v == nil {
1568		return nil
1569	}
1570	invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRouteHeaders"}
1571	for i := range v {
1572		if err := validateHttpGatewayRouteHeader(&v[i]); err != nil {
1573			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1574		}
1575	}
1576	if invalidParams.Len() > 0 {
1577		return invalidParams
1578	} else {
1579		return nil
1580	}
1581}
1582
1583func validateHttpGatewayRouteMatch(v *types.HttpGatewayRouteMatch) error {
1584	if v == nil {
1585		return nil
1586	}
1587	invalidParams := smithy.InvalidParamsError{Context: "HttpGatewayRouteMatch"}
1588	if v.QueryParameters != nil {
1589		if err := validateHttpQueryParameters(v.QueryParameters); err != nil {
1590			invalidParams.AddNested("QueryParameters", err.(smithy.InvalidParamsError))
1591		}
1592	}
1593	if v.Headers != nil {
1594		if err := validateHttpGatewayRouteHeaders(v.Headers); err != nil {
1595			invalidParams.AddNested("Headers", err.(smithy.InvalidParamsError))
1596		}
1597	}
1598	if invalidParams.Len() > 0 {
1599		return invalidParams
1600	} else {
1601		return nil
1602	}
1603}
1604
1605func validateHttpQueryParameter(v *types.HttpQueryParameter) error {
1606	if v == nil {
1607		return nil
1608	}
1609	invalidParams := smithy.InvalidParamsError{Context: "HttpQueryParameter"}
1610	if v.Name == nil {
1611		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1612	}
1613	if invalidParams.Len() > 0 {
1614		return invalidParams
1615	} else {
1616		return nil
1617	}
1618}
1619
1620func validateHttpQueryParameters(v []types.HttpQueryParameter) error {
1621	if v == nil {
1622		return nil
1623	}
1624	invalidParams := smithy.InvalidParamsError{Context: "HttpQueryParameters"}
1625	for i := range v {
1626		if err := validateHttpQueryParameter(&v[i]); err != nil {
1627			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1628		}
1629	}
1630	if invalidParams.Len() > 0 {
1631		return invalidParams
1632	} else {
1633		return nil
1634	}
1635}
1636
1637func validateHttpRetryPolicy(v *types.HttpRetryPolicy) error {
1638	if v == nil {
1639		return nil
1640	}
1641	invalidParams := smithy.InvalidParamsError{Context: "HttpRetryPolicy"}
1642	if v.PerRetryTimeout == nil {
1643		invalidParams.Add(smithy.NewErrParamRequired("PerRetryTimeout"))
1644	}
1645	if v.MaxRetries == nil {
1646		invalidParams.Add(smithy.NewErrParamRequired("MaxRetries"))
1647	}
1648	if invalidParams.Len() > 0 {
1649		return invalidParams
1650	} else {
1651		return nil
1652	}
1653}
1654
1655func validateHttpRoute(v *types.HttpRoute) error {
1656	if v == nil {
1657		return nil
1658	}
1659	invalidParams := smithy.InvalidParamsError{Context: "HttpRoute"}
1660	if v.Match == nil {
1661		invalidParams.Add(smithy.NewErrParamRequired("Match"))
1662	} else if v.Match != nil {
1663		if err := validateHttpRouteMatch(v.Match); err != nil {
1664			invalidParams.AddNested("Match", err.(smithy.InvalidParamsError))
1665		}
1666	}
1667	if v.Action == nil {
1668		invalidParams.Add(smithy.NewErrParamRequired("Action"))
1669	} else if v.Action != nil {
1670		if err := validateHttpRouteAction(v.Action); err != nil {
1671			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
1672		}
1673	}
1674	if v.RetryPolicy != nil {
1675		if err := validateHttpRetryPolicy(v.RetryPolicy); err != nil {
1676			invalidParams.AddNested("RetryPolicy", err.(smithy.InvalidParamsError))
1677		}
1678	}
1679	if invalidParams.Len() > 0 {
1680		return invalidParams
1681	} else {
1682		return nil
1683	}
1684}
1685
1686func validateHttpRouteAction(v *types.HttpRouteAction) error {
1687	if v == nil {
1688		return nil
1689	}
1690	invalidParams := smithy.InvalidParamsError{Context: "HttpRouteAction"}
1691	if v.WeightedTargets == nil {
1692		invalidParams.Add(smithy.NewErrParamRequired("WeightedTargets"))
1693	} else if v.WeightedTargets != nil {
1694		if err := validateWeightedTargets(v.WeightedTargets); err != nil {
1695			invalidParams.AddNested("WeightedTargets", err.(smithy.InvalidParamsError))
1696		}
1697	}
1698	if invalidParams.Len() > 0 {
1699		return invalidParams
1700	} else {
1701		return nil
1702	}
1703}
1704
1705func validateHttpRouteHeader(v *types.HttpRouteHeader) error {
1706	if v == nil {
1707		return nil
1708	}
1709	invalidParams := smithy.InvalidParamsError{Context: "HttpRouteHeader"}
1710	if v.Name == nil {
1711		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1712	}
1713	if v.Match != nil {
1714		if err := validateHeaderMatchMethod(v.Match); err != nil {
1715			invalidParams.AddNested("Match", err.(smithy.InvalidParamsError))
1716		}
1717	}
1718	if invalidParams.Len() > 0 {
1719		return invalidParams
1720	} else {
1721		return nil
1722	}
1723}
1724
1725func validateHttpRouteHeaders(v []types.HttpRouteHeader) error {
1726	if v == nil {
1727		return nil
1728	}
1729	invalidParams := smithy.InvalidParamsError{Context: "HttpRouteHeaders"}
1730	for i := range v {
1731		if err := validateHttpRouteHeader(&v[i]); err != nil {
1732			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1733		}
1734	}
1735	if invalidParams.Len() > 0 {
1736		return invalidParams
1737	} else {
1738		return nil
1739	}
1740}
1741
1742func validateHttpRouteMatch(v *types.HttpRouteMatch) error {
1743	if v == nil {
1744		return nil
1745	}
1746	invalidParams := smithy.InvalidParamsError{Context: "HttpRouteMatch"}
1747	if v.QueryParameters != nil {
1748		if err := validateHttpQueryParameters(v.QueryParameters); err != nil {
1749			invalidParams.AddNested("QueryParameters", err.(smithy.InvalidParamsError))
1750		}
1751	}
1752	if v.Headers != nil {
1753		if err := validateHttpRouteHeaders(v.Headers); err != nil {
1754			invalidParams.AddNested("Headers", err.(smithy.InvalidParamsError))
1755		}
1756	}
1757	if invalidParams.Len() > 0 {
1758		return invalidParams
1759	} else {
1760		return nil
1761	}
1762}
1763
1764func validateListener(v *types.Listener) error {
1765	if v == nil {
1766		return nil
1767	}
1768	invalidParams := smithy.InvalidParamsError{Context: "Listener"}
1769	if v.PortMapping == nil {
1770		invalidParams.Add(smithy.NewErrParamRequired("PortMapping"))
1771	} else if v.PortMapping != nil {
1772		if err := validatePortMapping(v.PortMapping); err != nil {
1773			invalidParams.AddNested("PortMapping", err.(smithy.InvalidParamsError))
1774		}
1775	}
1776	if v.Tls != nil {
1777		if err := validateListenerTls(v.Tls); err != nil {
1778			invalidParams.AddNested("Tls", err.(smithy.InvalidParamsError))
1779		}
1780	}
1781	if v.HealthCheck != nil {
1782		if err := validateHealthCheckPolicy(v.HealthCheck); err != nil {
1783			invalidParams.AddNested("HealthCheck", err.(smithy.InvalidParamsError))
1784		}
1785	}
1786	if v.OutlierDetection != nil {
1787		if err := validateOutlierDetection(v.OutlierDetection); err != nil {
1788			invalidParams.AddNested("OutlierDetection", err.(smithy.InvalidParamsError))
1789		}
1790	}
1791	if v.ConnectionPool != nil {
1792		if err := validateVirtualNodeConnectionPool(v.ConnectionPool); err != nil {
1793			invalidParams.AddNested("ConnectionPool", err.(smithy.InvalidParamsError))
1794		}
1795	}
1796	if invalidParams.Len() > 0 {
1797		return invalidParams
1798	} else {
1799		return nil
1800	}
1801}
1802
1803func validateListeners(v []types.Listener) error {
1804	if v == nil {
1805		return nil
1806	}
1807	invalidParams := smithy.InvalidParamsError{Context: "Listeners"}
1808	for i := range v {
1809		if err := validateListener(&v[i]); err != nil {
1810			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1811		}
1812	}
1813	if invalidParams.Len() > 0 {
1814		return invalidParams
1815	} else {
1816		return nil
1817	}
1818}
1819
1820func validateListenerTls(v *types.ListenerTls) error {
1821	if v == nil {
1822		return nil
1823	}
1824	invalidParams := smithy.InvalidParamsError{Context: "ListenerTls"}
1825	if len(v.Mode) == 0 {
1826		invalidParams.Add(smithy.NewErrParamRequired("Mode"))
1827	}
1828	if v.Certificate == nil {
1829		invalidParams.Add(smithy.NewErrParamRequired("Certificate"))
1830	} else if v.Certificate != nil {
1831		if err := validateListenerTlsCertificate(v.Certificate); err != nil {
1832			invalidParams.AddNested("Certificate", err.(smithy.InvalidParamsError))
1833		}
1834	}
1835	if v.Validation != nil {
1836		if err := validateListenerTlsValidationContext(v.Validation); err != nil {
1837			invalidParams.AddNested("Validation", err.(smithy.InvalidParamsError))
1838		}
1839	}
1840	if invalidParams.Len() > 0 {
1841		return invalidParams
1842	} else {
1843		return nil
1844	}
1845}
1846
1847func validateListenerTlsAcmCertificate(v *types.ListenerTlsAcmCertificate) error {
1848	if v == nil {
1849		return nil
1850	}
1851	invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsAcmCertificate"}
1852	if v.CertificateArn == nil {
1853		invalidParams.Add(smithy.NewErrParamRequired("CertificateArn"))
1854	}
1855	if invalidParams.Len() > 0 {
1856		return invalidParams
1857	} else {
1858		return nil
1859	}
1860}
1861
1862func validateListenerTlsCertificate(v types.ListenerTlsCertificate) error {
1863	if v == nil {
1864		return nil
1865	}
1866	invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsCertificate"}
1867	switch uv := v.(type) {
1868	case *types.ListenerTlsCertificateMemberAcm:
1869		if err := validateListenerTlsAcmCertificate(&uv.Value); err != nil {
1870			invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError))
1871		}
1872
1873	case *types.ListenerTlsCertificateMemberFile:
1874		if err := validateListenerTlsFileCertificate(&uv.Value); err != nil {
1875			invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError))
1876		}
1877
1878	case *types.ListenerTlsCertificateMemberSds:
1879		if err := validateListenerTlsSdsCertificate(&uv.Value); err != nil {
1880			invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError))
1881		}
1882
1883	}
1884	if invalidParams.Len() > 0 {
1885		return invalidParams
1886	} else {
1887		return nil
1888	}
1889}
1890
1891func validateListenerTlsFileCertificate(v *types.ListenerTlsFileCertificate) error {
1892	if v == nil {
1893		return nil
1894	}
1895	invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsFileCertificate"}
1896	if v.CertificateChain == nil {
1897		invalidParams.Add(smithy.NewErrParamRequired("CertificateChain"))
1898	}
1899	if v.PrivateKey == nil {
1900		invalidParams.Add(smithy.NewErrParamRequired("PrivateKey"))
1901	}
1902	if invalidParams.Len() > 0 {
1903		return invalidParams
1904	} else {
1905		return nil
1906	}
1907}
1908
1909func validateListenerTlsSdsCertificate(v *types.ListenerTlsSdsCertificate) error {
1910	if v == nil {
1911		return nil
1912	}
1913	invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsSdsCertificate"}
1914	if v.SecretName == nil {
1915		invalidParams.Add(smithy.NewErrParamRequired("SecretName"))
1916	}
1917	if invalidParams.Len() > 0 {
1918		return invalidParams
1919	} else {
1920		return nil
1921	}
1922}
1923
1924func validateListenerTlsValidationContext(v *types.ListenerTlsValidationContext) error {
1925	if v == nil {
1926		return nil
1927	}
1928	invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsValidationContext"}
1929	if v.Trust == nil {
1930		invalidParams.Add(smithy.NewErrParamRequired("Trust"))
1931	} else if v.Trust != nil {
1932		if err := validateListenerTlsValidationContextTrust(v.Trust); err != nil {
1933			invalidParams.AddNested("Trust", err.(smithy.InvalidParamsError))
1934		}
1935	}
1936	if v.SubjectAlternativeNames != nil {
1937		if err := validateSubjectAlternativeNames(v.SubjectAlternativeNames); err != nil {
1938			invalidParams.AddNested("SubjectAlternativeNames", err.(smithy.InvalidParamsError))
1939		}
1940	}
1941	if invalidParams.Len() > 0 {
1942		return invalidParams
1943	} else {
1944		return nil
1945	}
1946}
1947
1948func validateListenerTlsValidationContextTrust(v types.ListenerTlsValidationContextTrust) error {
1949	if v == nil {
1950		return nil
1951	}
1952	invalidParams := smithy.InvalidParamsError{Context: "ListenerTlsValidationContextTrust"}
1953	switch uv := v.(type) {
1954	case *types.ListenerTlsValidationContextTrustMemberFile:
1955		if err := validateTlsValidationContextFileTrust(&uv.Value); err != nil {
1956			invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError))
1957		}
1958
1959	case *types.ListenerTlsValidationContextTrustMemberSds:
1960		if err := validateTlsValidationContextSdsTrust(&uv.Value); err != nil {
1961			invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError))
1962		}
1963
1964	}
1965	if invalidParams.Len() > 0 {
1966		return invalidParams
1967	} else {
1968		return nil
1969	}
1970}
1971
1972func validateLogging(v *types.Logging) error {
1973	if v == nil {
1974		return nil
1975	}
1976	invalidParams := smithy.InvalidParamsError{Context: "Logging"}
1977	if v.AccessLog != nil {
1978		if err := validateAccessLog(v.AccessLog); err != nil {
1979			invalidParams.AddNested("AccessLog", err.(smithy.InvalidParamsError))
1980		}
1981	}
1982	if invalidParams.Len() > 0 {
1983		return invalidParams
1984	} else {
1985		return nil
1986	}
1987}
1988
1989func validateMatchRange(v *types.MatchRange) error {
1990	if v == nil {
1991		return nil
1992	}
1993	invalidParams := smithy.InvalidParamsError{Context: "MatchRange"}
1994	if v.Start == nil {
1995		invalidParams.Add(smithy.NewErrParamRequired("Start"))
1996	}
1997	if v.End == nil {
1998		invalidParams.Add(smithy.NewErrParamRequired("End"))
1999	}
2000	if invalidParams.Len() > 0 {
2001		return invalidParams
2002	} else {
2003		return nil
2004	}
2005}
2006
2007func validateMeshSpec(v *types.MeshSpec) error {
2008	if v == nil {
2009		return nil
2010	}
2011	invalidParams := smithy.InvalidParamsError{Context: "MeshSpec"}
2012	if v.EgressFilter != nil {
2013		if err := validateEgressFilter(v.EgressFilter); err != nil {
2014			invalidParams.AddNested("EgressFilter", err.(smithy.InvalidParamsError))
2015		}
2016	}
2017	if invalidParams.Len() > 0 {
2018		return invalidParams
2019	} else {
2020		return nil
2021	}
2022}
2023
2024func validateOutlierDetection(v *types.OutlierDetection) error {
2025	if v == nil {
2026		return nil
2027	}
2028	invalidParams := smithy.InvalidParamsError{Context: "OutlierDetection"}
2029	if v.MaxServerErrors == nil {
2030		invalidParams.Add(smithy.NewErrParamRequired("MaxServerErrors"))
2031	}
2032	if v.Interval == nil {
2033		invalidParams.Add(smithy.NewErrParamRequired("Interval"))
2034	}
2035	if v.BaseEjectionDuration == nil {
2036		invalidParams.Add(smithy.NewErrParamRequired("BaseEjectionDuration"))
2037	}
2038	if v.MaxEjectionPercent == nil {
2039		invalidParams.Add(smithy.NewErrParamRequired("MaxEjectionPercent"))
2040	}
2041	if invalidParams.Len() > 0 {
2042		return invalidParams
2043	} else {
2044		return nil
2045	}
2046}
2047
2048func validatePortMapping(v *types.PortMapping) error {
2049	if v == nil {
2050		return nil
2051	}
2052	invalidParams := smithy.InvalidParamsError{Context: "PortMapping"}
2053	if len(v.Protocol) == 0 {
2054		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
2055	}
2056	if invalidParams.Len() > 0 {
2057		return invalidParams
2058	} else {
2059		return nil
2060	}
2061}
2062
2063func validateRouteSpec(v *types.RouteSpec) error {
2064	if v == nil {
2065		return nil
2066	}
2067	invalidParams := smithy.InvalidParamsError{Context: "RouteSpec"}
2068	if v.HttpRoute != nil {
2069		if err := validateHttpRoute(v.HttpRoute); err != nil {
2070			invalidParams.AddNested("HttpRoute", err.(smithy.InvalidParamsError))
2071		}
2072	}
2073	if v.TcpRoute != nil {
2074		if err := validateTcpRoute(v.TcpRoute); err != nil {
2075			invalidParams.AddNested("TcpRoute", err.(smithy.InvalidParamsError))
2076		}
2077	}
2078	if v.Http2Route != nil {
2079		if err := validateHttpRoute(v.Http2Route); err != nil {
2080			invalidParams.AddNested("Http2Route", err.(smithy.InvalidParamsError))
2081		}
2082	}
2083	if v.GrpcRoute != nil {
2084		if err := validateGrpcRoute(v.GrpcRoute); err != nil {
2085			invalidParams.AddNested("GrpcRoute", err.(smithy.InvalidParamsError))
2086		}
2087	}
2088	if invalidParams.Len() > 0 {
2089		return invalidParams
2090	} else {
2091		return nil
2092	}
2093}
2094
2095func validateServiceDiscovery(v types.ServiceDiscovery) error {
2096	if v == nil {
2097		return nil
2098	}
2099	invalidParams := smithy.InvalidParamsError{Context: "ServiceDiscovery"}
2100	switch uv := v.(type) {
2101	case *types.ServiceDiscoveryMemberAwsCloudMap:
2102		if err := validateAwsCloudMapServiceDiscovery(&uv.Value); err != nil {
2103			invalidParams.AddNested("[awsCloudMap]", err.(smithy.InvalidParamsError))
2104		}
2105
2106	case *types.ServiceDiscoveryMemberDns:
2107		if err := validateDnsServiceDiscovery(&uv.Value); err != nil {
2108			invalidParams.AddNested("[dns]", err.(smithy.InvalidParamsError))
2109		}
2110
2111	}
2112	if invalidParams.Len() > 0 {
2113		return invalidParams
2114	} else {
2115		return nil
2116	}
2117}
2118
2119func validateSubjectAlternativeNameMatchers(v *types.SubjectAlternativeNameMatchers) error {
2120	if v == nil {
2121		return nil
2122	}
2123	invalidParams := smithy.InvalidParamsError{Context: "SubjectAlternativeNameMatchers"}
2124	if v.Exact == nil {
2125		invalidParams.Add(smithy.NewErrParamRequired("Exact"))
2126	}
2127	if invalidParams.Len() > 0 {
2128		return invalidParams
2129	} else {
2130		return nil
2131	}
2132}
2133
2134func validateSubjectAlternativeNames(v *types.SubjectAlternativeNames) error {
2135	if v == nil {
2136		return nil
2137	}
2138	invalidParams := smithy.InvalidParamsError{Context: "SubjectAlternativeNames"}
2139	if v.Match == nil {
2140		invalidParams.Add(smithy.NewErrParamRequired("Match"))
2141	} else if v.Match != nil {
2142		if err := validateSubjectAlternativeNameMatchers(v.Match); err != nil {
2143			invalidParams.AddNested("Match", err.(smithy.InvalidParamsError))
2144		}
2145	}
2146	if invalidParams.Len() > 0 {
2147		return invalidParams
2148	} else {
2149		return nil
2150	}
2151}
2152
2153func validateTagList(v []types.TagRef) error {
2154	if v == nil {
2155		return nil
2156	}
2157	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
2158	for i := range v {
2159		if err := validateTagRef(&v[i]); err != nil {
2160			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2161		}
2162	}
2163	if invalidParams.Len() > 0 {
2164		return invalidParams
2165	} else {
2166		return nil
2167	}
2168}
2169
2170func validateTagRef(v *types.TagRef) error {
2171	if v == nil {
2172		return nil
2173	}
2174	invalidParams := smithy.InvalidParamsError{Context: "TagRef"}
2175	if v.Key == nil {
2176		invalidParams.Add(smithy.NewErrParamRequired("Key"))
2177	}
2178	if v.Value == nil {
2179		invalidParams.Add(smithy.NewErrParamRequired("Value"))
2180	}
2181	if invalidParams.Len() > 0 {
2182		return invalidParams
2183	} else {
2184		return nil
2185	}
2186}
2187
2188func validateTcpRoute(v *types.TcpRoute) error {
2189	if v == nil {
2190		return nil
2191	}
2192	invalidParams := smithy.InvalidParamsError{Context: "TcpRoute"}
2193	if v.Action == nil {
2194		invalidParams.Add(smithy.NewErrParamRequired("Action"))
2195	} else if v.Action != nil {
2196		if err := validateTcpRouteAction(v.Action); err != nil {
2197			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
2198		}
2199	}
2200	if invalidParams.Len() > 0 {
2201		return invalidParams
2202	} else {
2203		return nil
2204	}
2205}
2206
2207func validateTcpRouteAction(v *types.TcpRouteAction) error {
2208	if v == nil {
2209		return nil
2210	}
2211	invalidParams := smithy.InvalidParamsError{Context: "TcpRouteAction"}
2212	if v.WeightedTargets == nil {
2213		invalidParams.Add(smithy.NewErrParamRequired("WeightedTargets"))
2214	} else if v.WeightedTargets != nil {
2215		if err := validateWeightedTargets(v.WeightedTargets); err != nil {
2216			invalidParams.AddNested("WeightedTargets", err.(smithy.InvalidParamsError))
2217		}
2218	}
2219	if invalidParams.Len() > 0 {
2220		return invalidParams
2221	} else {
2222		return nil
2223	}
2224}
2225
2226func validateTlsValidationContext(v *types.TlsValidationContext) error {
2227	if v == nil {
2228		return nil
2229	}
2230	invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContext"}
2231	if v.Trust == nil {
2232		invalidParams.Add(smithy.NewErrParamRequired("Trust"))
2233	} else if v.Trust != nil {
2234		if err := validateTlsValidationContextTrust(v.Trust); err != nil {
2235			invalidParams.AddNested("Trust", err.(smithy.InvalidParamsError))
2236		}
2237	}
2238	if v.SubjectAlternativeNames != nil {
2239		if err := validateSubjectAlternativeNames(v.SubjectAlternativeNames); err != nil {
2240			invalidParams.AddNested("SubjectAlternativeNames", err.(smithy.InvalidParamsError))
2241		}
2242	}
2243	if invalidParams.Len() > 0 {
2244		return invalidParams
2245	} else {
2246		return nil
2247	}
2248}
2249
2250func validateTlsValidationContextAcmTrust(v *types.TlsValidationContextAcmTrust) error {
2251	if v == nil {
2252		return nil
2253	}
2254	invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContextAcmTrust"}
2255	if v.CertificateAuthorityArns == nil {
2256		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArns"))
2257	}
2258	if invalidParams.Len() > 0 {
2259		return invalidParams
2260	} else {
2261		return nil
2262	}
2263}
2264
2265func validateTlsValidationContextFileTrust(v *types.TlsValidationContextFileTrust) error {
2266	if v == nil {
2267		return nil
2268	}
2269	invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContextFileTrust"}
2270	if v.CertificateChain == nil {
2271		invalidParams.Add(smithy.NewErrParamRequired("CertificateChain"))
2272	}
2273	if invalidParams.Len() > 0 {
2274		return invalidParams
2275	} else {
2276		return nil
2277	}
2278}
2279
2280func validateTlsValidationContextSdsTrust(v *types.TlsValidationContextSdsTrust) error {
2281	if v == nil {
2282		return nil
2283	}
2284	invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContextSdsTrust"}
2285	if v.SecretName == nil {
2286		invalidParams.Add(smithy.NewErrParamRequired("SecretName"))
2287	}
2288	if invalidParams.Len() > 0 {
2289		return invalidParams
2290	} else {
2291		return nil
2292	}
2293}
2294
2295func validateTlsValidationContextTrust(v types.TlsValidationContextTrust) error {
2296	if v == nil {
2297		return nil
2298	}
2299	invalidParams := smithy.InvalidParamsError{Context: "TlsValidationContextTrust"}
2300	switch uv := v.(type) {
2301	case *types.TlsValidationContextTrustMemberAcm:
2302		if err := validateTlsValidationContextAcmTrust(&uv.Value); err != nil {
2303			invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError))
2304		}
2305
2306	case *types.TlsValidationContextTrustMemberFile:
2307		if err := validateTlsValidationContextFileTrust(&uv.Value); err != nil {
2308			invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError))
2309		}
2310
2311	case *types.TlsValidationContextTrustMemberSds:
2312		if err := validateTlsValidationContextSdsTrust(&uv.Value); err != nil {
2313			invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError))
2314		}
2315
2316	}
2317	if invalidParams.Len() > 0 {
2318		return invalidParams
2319	} else {
2320		return nil
2321	}
2322}
2323
2324func validateVirtualGatewayAccessLog(v types.VirtualGatewayAccessLog) error {
2325	if v == nil {
2326		return nil
2327	}
2328	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayAccessLog"}
2329	switch uv := v.(type) {
2330	case *types.VirtualGatewayAccessLogMemberFile:
2331		if err := validateVirtualGatewayFileAccessLog(&uv.Value); err != nil {
2332			invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError))
2333		}
2334
2335	}
2336	if invalidParams.Len() > 0 {
2337		return invalidParams
2338	} else {
2339		return nil
2340	}
2341}
2342
2343func validateVirtualGatewayBackendDefaults(v *types.VirtualGatewayBackendDefaults) error {
2344	if v == nil {
2345		return nil
2346	}
2347	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayBackendDefaults"}
2348	if v.ClientPolicy != nil {
2349		if err := validateVirtualGatewayClientPolicy(v.ClientPolicy); err != nil {
2350			invalidParams.AddNested("ClientPolicy", err.(smithy.InvalidParamsError))
2351		}
2352	}
2353	if invalidParams.Len() > 0 {
2354		return invalidParams
2355	} else {
2356		return nil
2357	}
2358}
2359
2360func validateVirtualGatewayClientPolicy(v *types.VirtualGatewayClientPolicy) error {
2361	if v == nil {
2362		return nil
2363	}
2364	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayClientPolicy"}
2365	if v.Tls != nil {
2366		if err := validateVirtualGatewayClientPolicyTls(v.Tls); err != nil {
2367			invalidParams.AddNested("Tls", err.(smithy.InvalidParamsError))
2368		}
2369	}
2370	if invalidParams.Len() > 0 {
2371		return invalidParams
2372	} else {
2373		return nil
2374	}
2375}
2376
2377func validateVirtualGatewayClientPolicyTls(v *types.VirtualGatewayClientPolicyTls) error {
2378	if v == nil {
2379		return nil
2380	}
2381	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayClientPolicyTls"}
2382	if v.Certificate != nil {
2383		if err := validateVirtualGatewayClientTlsCertificate(v.Certificate); err != nil {
2384			invalidParams.AddNested("Certificate", err.(smithy.InvalidParamsError))
2385		}
2386	}
2387	if v.Validation == nil {
2388		invalidParams.Add(smithy.NewErrParamRequired("Validation"))
2389	} else if v.Validation != nil {
2390		if err := validateVirtualGatewayTlsValidationContext(v.Validation); err != nil {
2391			invalidParams.AddNested("Validation", err.(smithy.InvalidParamsError))
2392		}
2393	}
2394	if invalidParams.Len() > 0 {
2395		return invalidParams
2396	} else {
2397		return nil
2398	}
2399}
2400
2401func validateVirtualGatewayClientTlsCertificate(v types.VirtualGatewayClientTlsCertificate) error {
2402	if v == nil {
2403		return nil
2404	}
2405	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayClientTlsCertificate"}
2406	switch uv := v.(type) {
2407	case *types.VirtualGatewayClientTlsCertificateMemberFile:
2408		if err := validateVirtualGatewayListenerTlsFileCertificate(&uv.Value); err != nil {
2409			invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError))
2410		}
2411
2412	case *types.VirtualGatewayClientTlsCertificateMemberSds:
2413		if err := validateVirtualGatewayListenerTlsSdsCertificate(&uv.Value); err != nil {
2414			invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError))
2415		}
2416
2417	}
2418	if invalidParams.Len() > 0 {
2419		return invalidParams
2420	} else {
2421		return nil
2422	}
2423}
2424
2425func validateVirtualGatewayConnectionPool(v types.VirtualGatewayConnectionPool) error {
2426	if v == nil {
2427		return nil
2428	}
2429	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayConnectionPool"}
2430	switch uv := v.(type) {
2431	case *types.VirtualGatewayConnectionPoolMemberGrpc:
2432		if err := validateVirtualGatewayGrpcConnectionPool(&uv.Value); err != nil {
2433			invalidParams.AddNested("[grpc]", err.(smithy.InvalidParamsError))
2434		}
2435
2436	case *types.VirtualGatewayConnectionPoolMemberHttp:
2437		if err := validateVirtualGatewayHttpConnectionPool(&uv.Value); err != nil {
2438			invalidParams.AddNested("[http]", err.(smithy.InvalidParamsError))
2439		}
2440
2441	case *types.VirtualGatewayConnectionPoolMemberHttp2:
2442		if err := validateVirtualGatewayHttp2ConnectionPool(&uv.Value); err != nil {
2443			invalidParams.AddNested("[http2]", err.(smithy.InvalidParamsError))
2444		}
2445
2446	}
2447	if invalidParams.Len() > 0 {
2448		return invalidParams
2449	} else {
2450		return nil
2451	}
2452}
2453
2454func validateVirtualGatewayFileAccessLog(v *types.VirtualGatewayFileAccessLog) error {
2455	if v == nil {
2456		return nil
2457	}
2458	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayFileAccessLog"}
2459	if v.Path == nil {
2460		invalidParams.Add(smithy.NewErrParamRequired("Path"))
2461	}
2462	if invalidParams.Len() > 0 {
2463		return invalidParams
2464	} else {
2465		return nil
2466	}
2467}
2468
2469func validateVirtualGatewayGrpcConnectionPool(v *types.VirtualGatewayGrpcConnectionPool) error {
2470	if v == nil {
2471		return nil
2472	}
2473	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayGrpcConnectionPool"}
2474	if invalidParams.Len() > 0 {
2475		return invalidParams
2476	} else {
2477		return nil
2478	}
2479}
2480
2481func validateVirtualGatewayHealthCheckPolicy(v *types.VirtualGatewayHealthCheckPolicy) error {
2482	if v == nil {
2483		return nil
2484	}
2485	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayHealthCheckPolicy"}
2486	if v.TimeoutMillis == nil {
2487		invalidParams.Add(smithy.NewErrParamRequired("TimeoutMillis"))
2488	}
2489	if v.IntervalMillis == nil {
2490		invalidParams.Add(smithy.NewErrParamRequired("IntervalMillis"))
2491	}
2492	if len(v.Protocol) == 0 {
2493		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
2494	}
2495	if invalidParams.Len() > 0 {
2496		return invalidParams
2497	} else {
2498		return nil
2499	}
2500}
2501
2502func validateVirtualGatewayHttp2ConnectionPool(v *types.VirtualGatewayHttp2ConnectionPool) error {
2503	if v == nil {
2504		return nil
2505	}
2506	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayHttp2ConnectionPool"}
2507	if invalidParams.Len() > 0 {
2508		return invalidParams
2509	} else {
2510		return nil
2511	}
2512}
2513
2514func validateVirtualGatewayHttpConnectionPool(v *types.VirtualGatewayHttpConnectionPool) error {
2515	if v == nil {
2516		return nil
2517	}
2518	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayHttpConnectionPool"}
2519	if invalidParams.Len() > 0 {
2520		return invalidParams
2521	} else {
2522		return nil
2523	}
2524}
2525
2526func validateVirtualGatewayListener(v *types.VirtualGatewayListener) error {
2527	if v == nil {
2528		return nil
2529	}
2530	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListener"}
2531	if v.HealthCheck != nil {
2532		if err := validateVirtualGatewayHealthCheckPolicy(v.HealthCheck); err != nil {
2533			invalidParams.AddNested("HealthCheck", err.(smithy.InvalidParamsError))
2534		}
2535	}
2536	if v.PortMapping == nil {
2537		invalidParams.Add(smithy.NewErrParamRequired("PortMapping"))
2538	} else if v.PortMapping != nil {
2539		if err := validateVirtualGatewayPortMapping(v.PortMapping); err != nil {
2540			invalidParams.AddNested("PortMapping", err.(smithy.InvalidParamsError))
2541		}
2542	}
2543	if v.Tls != nil {
2544		if err := validateVirtualGatewayListenerTls(v.Tls); err != nil {
2545			invalidParams.AddNested("Tls", err.(smithy.InvalidParamsError))
2546		}
2547	}
2548	if v.ConnectionPool != nil {
2549		if err := validateVirtualGatewayConnectionPool(v.ConnectionPool); err != nil {
2550			invalidParams.AddNested("ConnectionPool", err.(smithy.InvalidParamsError))
2551		}
2552	}
2553	if invalidParams.Len() > 0 {
2554		return invalidParams
2555	} else {
2556		return nil
2557	}
2558}
2559
2560func validateVirtualGatewayListeners(v []types.VirtualGatewayListener) error {
2561	if v == nil {
2562		return nil
2563	}
2564	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListeners"}
2565	for i := range v {
2566		if err := validateVirtualGatewayListener(&v[i]); err != nil {
2567			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2568		}
2569	}
2570	if invalidParams.Len() > 0 {
2571		return invalidParams
2572	} else {
2573		return nil
2574	}
2575}
2576
2577func validateVirtualGatewayListenerTls(v *types.VirtualGatewayListenerTls) error {
2578	if v == nil {
2579		return nil
2580	}
2581	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTls"}
2582	if len(v.Mode) == 0 {
2583		invalidParams.Add(smithy.NewErrParamRequired("Mode"))
2584	}
2585	if v.Validation != nil {
2586		if err := validateVirtualGatewayListenerTlsValidationContext(v.Validation); err != nil {
2587			invalidParams.AddNested("Validation", err.(smithy.InvalidParamsError))
2588		}
2589	}
2590	if v.Certificate == nil {
2591		invalidParams.Add(smithy.NewErrParamRequired("Certificate"))
2592	} else if v.Certificate != nil {
2593		if err := validateVirtualGatewayListenerTlsCertificate(v.Certificate); err != nil {
2594			invalidParams.AddNested("Certificate", err.(smithy.InvalidParamsError))
2595		}
2596	}
2597	if invalidParams.Len() > 0 {
2598		return invalidParams
2599	} else {
2600		return nil
2601	}
2602}
2603
2604func validateVirtualGatewayListenerTlsAcmCertificate(v *types.VirtualGatewayListenerTlsAcmCertificate) error {
2605	if v == nil {
2606		return nil
2607	}
2608	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsAcmCertificate"}
2609	if v.CertificateArn == nil {
2610		invalidParams.Add(smithy.NewErrParamRequired("CertificateArn"))
2611	}
2612	if invalidParams.Len() > 0 {
2613		return invalidParams
2614	} else {
2615		return nil
2616	}
2617}
2618
2619func validateVirtualGatewayListenerTlsCertificate(v types.VirtualGatewayListenerTlsCertificate) error {
2620	if v == nil {
2621		return nil
2622	}
2623	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsCertificate"}
2624	switch uv := v.(type) {
2625	case *types.VirtualGatewayListenerTlsCertificateMemberAcm:
2626		if err := validateVirtualGatewayListenerTlsAcmCertificate(&uv.Value); err != nil {
2627			invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError))
2628		}
2629
2630	case *types.VirtualGatewayListenerTlsCertificateMemberFile:
2631		if err := validateVirtualGatewayListenerTlsFileCertificate(&uv.Value); err != nil {
2632			invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError))
2633		}
2634
2635	case *types.VirtualGatewayListenerTlsCertificateMemberSds:
2636		if err := validateVirtualGatewayListenerTlsSdsCertificate(&uv.Value); err != nil {
2637			invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError))
2638		}
2639
2640	}
2641	if invalidParams.Len() > 0 {
2642		return invalidParams
2643	} else {
2644		return nil
2645	}
2646}
2647
2648func validateVirtualGatewayListenerTlsFileCertificate(v *types.VirtualGatewayListenerTlsFileCertificate) error {
2649	if v == nil {
2650		return nil
2651	}
2652	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsFileCertificate"}
2653	if v.CertificateChain == nil {
2654		invalidParams.Add(smithy.NewErrParamRequired("CertificateChain"))
2655	}
2656	if v.PrivateKey == nil {
2657		invalidParams.Add(smithy.NewErrParamRequired("PrivateKey"))
2658	}
2659	if invalidParams.Len() > 0 {
2660		return invalidParams
2661	} else {
2662		return nil
2663	}
2664}
2665
2666func validateVirtualGatewayListenerTlsSdsCertificate(v *types.VirtualGatewayListenerTlsSdsCertificate) error {
2667	if v == nil {
2668		return nil
2669	}
2670	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsSdsCertificate"}
2671	if v.SecretName == nil {
2672		invalidParams.Add(smithy.NewErrParamRequired("SecretName"))
2673	}
2674	if invalidParams.Len() > 0 {
2675		return invalidParams
2676	} else {
2677		return nil
2678	}
2679}
2680
2681func validateVirtualGatewayListenerTlsValidationContext(v *types.VirtualGatewayListenerTlsValidationContext) error {
2682	if v == nil {
2683		return nil
2684	}
2685	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsValidationContext"}
2686	if v.Trust == nil {
2687		invalidParams.Add(smithy.NewErrParamRequired("Trust"))
2688	} else if v.Trust != nil {
2689		if err := validateVirtualGatewayListenerTlsValidationContextTrust(v.Trust); err != nil {
2690			invalidParams.AddNested("Trust", err.(smithy.InvalidParamsError))
2691		}
2692	}
2693	if v.SubjectAlternativeNames != nil {
2694		if err := validateSubjectAlternativeNames(v.SubjectAlternativeNames); err != nil {
2695			invalidParams.AddNested("SubjectAlternativeNames", err.(smithy.InvalidParamsError))
2696		}
2697	}
2698	if invalidParams.Len() > 0 {
2699		return invalidParams
2700	} else {
2701		return nil
2702	}
2703}
2704
2705func validateVirtualGatewayListenerTlsValidationContextTrust(v types.VirtualGatewayListenerTlsValidationContextTrust) error {
2706	if v == nil {
2707		return nil
2708	}
2709	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayListenerTlsValidationContextTrust"}
2710	switch uv := v.(type) {
2711	case *types.VirtualGatewayListenerTlsValidationContextTrustMemberFile:
2712		if err := validateVirtualGatewayTlsValidationContextFileTrust(&uv.Value); err != nil {
2713			invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError))
2714		}
2715
2716	case *types.VirtualGatewayListenerTlsValidationContextTrustMemberSds:
2717		if err := validateVirtualGatewayTlsValidationContextSdsTrust(&uv.Value); err != nil {
2718			invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError))
2719		}
2720
2721	}
2722	if invalidParams.Len() > 0 {
2723		return invalidParams
2724	} else {
2725		return nil
2726	}
2727}
2728
2729func validateVirtualGatewayLogging(v *types.VirtualGatewayLogging) error {
2730	if v == nil {
2731		return nil
2732	}
2733	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayLogging"}
2734	if v.AccessLog != nil {
2735		if err := validateVirtualGatewayAccessLog(v.AccessLog); err != nil {
2736			invalidParams.AddNested("AccessLog", err.(smithy.InvalidParamsError))
2737		}
2738	}
2739	if invalidParams.Len() > 0 {
2740		return invalidParams
2741	} else {
2742		return nil
2743	}
2744}
2745
2746func validateVirtualGatewayPortMapping(v *types.VirtualGatewayPortMapping) error {
2747	if v == nil {
2748		return nil
2749	}
2750	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayPortMapping"}
2751	if len(v.Protocol) == 0 {
2752		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
2753	}
2754	if invalidParams.Len() > 0 {
2755		return invalidParams
2756	} else {
2757		return nil
2758	}
2759}
2760
2761func validateVirtualGatewaySpec(v *types.VirtualGatewaySpec) error {
2762	if v == nil {
2763		return nil
2764	}
2765	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewaySpec"}
2766	if v.BackendDefaults != nil {
2767		if err := validateVirtualGatewayBackendDefaults(v.BackendDefaults); err != nil {
2768			invalidParams.AddNested("BackendDefaults", err.(smithy.InvalidParamsError))
2769		}
2770	}
2771	if v.Listeners == nil {
2772		invalidParams.Add(smithy.NewErrParamRequired("Listeners"))
2773	} else if v.Listeners != nil {
2774		if err := validateVirtualGatewayListeners(v.Listeners); err != nil {
2775			invalidParams.AddNested("Listeners", err.(smithy.InvalidParamsError))
2776		}
2777	}
2778	if v.Logging != nil {
2779		if err := validateVirtualGatewayLogging(v.Logging); err != nil {
2780			invalidParams.AddNested("Logging", err.(smithy.InvalidParamsError))
2781		}
2782	}
2783	if invalidParams.Len() > 0 {
2784		return invalidParams
2785	} else {
2786		return nil
2787	}
2788}
2789
2790func validateVirtualGatewayTlsValidationContext(v *types.VirtualGatewayTlsValidationContext) error {
2791	if v == nil {
2792		return nil
2793	}
2794	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContext"}
2795	if v.Trust == nil {
2796		invalidParams.Add(smithy.NewErrParamRequired("Trust"))
2797	} else if v.Trust != nil {
2798		if err := validateVirtualGatewayTlsValidationContextTrust(v.Trust); err != nil {
2799			invalidParams.AddNested("Trust", err.(smithy.InvalidParamsError))
2800		}
2801	}
2802	if v.SubjectAlternativeNames != nil {
2803		if err := validateSubjectAlternativeNames(v.SubjectAlternativeNames); err != nil {
2804			invalidParams.AddNested("SubjectAlternativeNames", err.(smithy.InvalidParamsError))
2805		}
2806	}
2807	if invalidParams.Len() > 0 {
2808		return invalidParams
2809	} else {
2810		return nil
2811	}
2812}
2813
2814func validateVirtualGatewayTlsValidationContextAcmTrust(v *types.VirtualGatewayTlsValidationContextAcmTrust) error {
2815	if v == nil {
2816		return nil
2817	}
2818	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContextAcmTrust"}
2819	if v.CertificateAuthorityArns == nil {
2820		invalidParams.Add(smithy.NewErrParamRequired("CertificateAuthorityArns"))
2821	}
2822	if invalidParams.Len() > 0 {
2823		return invalidParams
2824	} else {
2825		return nil
2826	}
2827}
2828
2829func validateVirtualGatewayTlsValidationContextFileTrust(v *types.VirtualGatewayTlsValidationContextFileTrust) error {
2830	if v == nil {
2831		return nil
2832	}
2833	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContextFileTrust"}
2834	if v.CertificateChain == nil {
2835		invalidParams.Add(smithy.NewErrParamRequired("CertificateChain"))
2836	}
2837	if invalidParams.Len() > 0 {
2838		return invalidParams
2839	} else {
2840		return nil
2841	}
2842}
2843
2844func validateVirtualGatewayTlsValidationContextSdsTrust(v *types.VirtualGatewayTlsValidationContextSdsTrust) error {
2845	if v == nil {
2846		return nil
2847	}
2848	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContextSdsTrust"}
2849	if v.SecretName == nil {
2850		invalidParams.Add(smithy.NewErrParamRequired("SecretName"))
2851	}
2852	if invalidParams.Len() > 0 {
2853		return invalidParams
2854	} else {
2855		return nil
2856	}
2857}
2858
2859func validateVirtualGatewayTlsValidationContextTrust(v types.VirtualGatewayTlsValidationContextTrust) error {
2860	if v == nil {
2861		return nil
2862	}
2863	invalidParams := smithy.InvalidParamsError{Context: "VirtualGatewayTlsValidationContextTrust"}
2864	switch uv := v.(type) {
2865	case *types.VirtualGatewayTlsValidationContextTrustMemberAcm:
2866		if err := validateVirtualGatewayTlsValidationContextAcmTrust(&uv.Value); err != nil {
2867			invalidParams.AddNested("[acm]", err.(smithy.InvalidParamsError))
2868		}
2869
2870	case *types.VirtualGatewayTlsValidationContextTrustMemberFile:
2871		if err := validateVirtualGatewayTlsValidationContextFileTrust(&uv.Value); err != nil {
2872			invalidParams.AddNested("[file]", err.(smithy.InvalidParamsError))
2873		}
2874
2875	case *types.VirtualGatewayTlsValidationContextTrustMemberSds:
2876		if err := validateVirtualGatewayTlsValidationContextSdsTrust(&uv.Value); err != nil {
2877			invalidParams.AddNested("[sds]", err.(smithy.InvalidParamsError))
2878		}
2879
2880	}
2881	if invalidParams.Len() > 0 {
2882		return invalidParams
2883	} else {
2884		return nil
2885	}
2886}
2887
2888func validateVirtualNodeConnectionPool(v types.VirtualNodeConnectionPool) error {
2889	if v == nil {
2890		return nil
2891	}
2892	invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeConnectionPool"}
2893	switch uv := v.(type) {
2894	case *types.VirtualNodeConnectionPoolMemberGrpc:
2895		if err := validateVirtualNodeGrpcConnectionPool(&uv.Value); err != nil {
2896			invalidParams.AddNested("[grpc]", err.(smithy.InvalidParamsError))
2897		}
2898
2899	case *types.VirtualNodeConnectionPoolMemberHttp:
2900		if err := validateVirtualNodeHttpConnectionPool(&uv.Value); err != nil {
2901			invalidParams.AddNested("[http]", err.(smithy.InvalidParamsError))
2902		}
2903
2904	case *types.VirtualNodeConnectionPoolMemberHttp2:
2905		if err := validateVirtualNodeHttp2ConnectionPool(&uv.Value); err != nil {
2906			invalidParams.AddNested("[http2]", err.(smithy.InvalidParamsError))
2907		}
2908
2909	case *types.VirtualNodeConnectionPoolMemberTcp:
2910		if err := validateVirtualNodeTcpConnectionPool(&uv.Value); err != nil {
2911			invalidParams.AddNested("[tcp]", err.(smithy.InvalidParamsError))
2912		}
2913
2914	}
2915	if invalidParams.Len() > 0 {
2916		return invalidParams
2917	} else {
2918		return nil
2919	}
2920}
2921
2922func validateVirtualNodeGrpcConnectionPool(v *types.VirtualNodeGrpcConnectionPool) error {
2923	if v == nil {
2924		return nil
2925	}
2926	invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeGrpcConnectionPool"}
2927	if invalidParams.Len() > 0 {
2928		return invalidParams
2929	} else {
2930		return nil
2931	}
2932}
2933
2934func validateVirtualNodeHttp2ConnectionPool(v *types.VirtualNodeHttp2ConnectionPool) error {
2935	if v == nil {
2936		return nil
2937	}
2938	invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeHttp2ConnectionPool"}
2939	if invalidParams.Len() > 0 {
2940		return invalidParams
2941	} else {
2942		return nil
2943	}
2944}
2945
2946func validateVirtualNodeHttpConnectionPool(v *types.VirtualNodeHttpConnectionPool) error {
2947	if v == nil {
2948		return nil
2949	}
2950	invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeHttpConnectionPool"}
2951	if invalidParams.Len() > 0 {
2952		return invalidParams
2953	} else {
2954		return nil
2955	}
2956}
2957
2958func validateVirtualNodeServiceProvider(v *types.VirtualNodeServiceProvider) error {
2959	if v == nil {
2960		return nil
2961	}
2962	invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeServiceProvider"}
2963	if v.VirtualNodeName == nil {
2964		invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName"))
2965	}
2966	if invalidParams.Len() > 0 {
2967		return invalidParams
2968	} else {
2969		return nil
2970	}
2971}
2972
2973func validateVirtualNodeSpec(v *types.VirtualNodeSpec) error {
2974	if v == nil {
2975		return nil
2976	}
2977	invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeSpec"}
2978	if v.ServiceDiscovery != nil {
2979		if err := validateServiceDiscovery(v.ServiceDiscovery); err != nil {
2980			invalidParams.AddNested("ServiceDiscovery", err.(smithy.InvalidParamsError))
2981		}
2982	}
2983	if v.Listeners != nil {
2984		if err := validateListeners(v.Listeners); err != nil {
2985			invalidParams.AddNested("Listeners", err.(smithy.InvalidParamsError))
2986		}
2987	}
2988	if v.Backends != nil {
2989		if err := validateBackends(v.Backends); err != nil {
2990			invalidParams.AddNested("Backends", err.(smithy.InvalidParamsError))
2991		}
2992	}
2993	if v.BackendDefaults != nil {
2994		if err := validateBackendDefaults(v.BackendDefaults); err != nil {
2995			invalidParams.AddNested("BackendDefaults", err.(smithy.InvalidParamsError))
2996		}
2997	}
2998	if v.Logging != nil {
2999		if err := validateLogging(v.Logging); err != nil {
3000			invalidParams.AddNested("Logging", err.(smithy.InvalidParamsError))
3001		}
3002	}
3003	if invalidParams.Len() > 0 {
3004		return invalidParams
3005	} else {
3006		return nil
3007	}
3008}
3009
3010func validateVirtualNodeTcpConnectionPool(v *types.VirtualNodeTcpConnectionPool) error {
3011	if v == nil {
3012		return nil
3013	}
3014	invalidParams := smithy.InvalidParamsError{Context: "VirtualNodeTcpConnectionPool"}
3015	if invalidParams.Len() > 0 {
3016		return invalidParams
3017	} else {
3018		return nil
3019	}
3020}
3021
3022func validateVirtualRouterListener(v *types.VirtualRouterListener) error {
3023	if v == nil {
3024		return nil
3025	}
3026	invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterListener"}
3027	if v.PortMapping == nil {
3028		invalidParams.Add(smithy.NewErrParamRequired("PortMapping"))
3029	} else if v.PortMapping != nil {
3030		if err := validatePortMapping(v.PortMapping); err != nil {
3031			invalidParams.AddNested("PortMapping", err.(smithy.InvalidParamsError))
3032		}
3033	}
3034	if invalidParams.Len() > 0 {
3035		return invalidParams
3036	} else {
3037		return nil
3038	}
3039}
3040
3041func validateVirtualRouterListeners(v []types.VirtualRouterListener) error {
3042	if v == nil {
3043		return nil
3044	}
3045	invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterListeners"}
3046	for i := range v {
3047		if err := validateVirtualRouterListener(&v[i]); err != nil {
3048			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3049		}
3050	}
3051	if invalidParams.Len() > 0 {
3052		return invalidParams
3053	} else {
3054		return nil
3055	}
3056}
3057
3058func validateVirtualRouterServiceProvider(v *types.VirtualRouterServiceProvider) error {
3059	if v == nil {
3060		return nil
3061	}
3062	invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterServiceProvider"}
3063	if v.VirtualRouterName == nil {
3064		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
3065	}
3066	if invalidParams.Len() > 0 {
3067		return invalidParams
3068	} else {
3069		return nil
3070	}
3071}
3072
3073func validateVirtualRouterSpec(v *types.VirtualRouterSpec) error {
3074	if v == nil {
3075		return nil
3076	}
3077	invalidParams := smithy.InvalidParamsError{Context: "VirtualRouterSpec"}
3078	if v.Listeners != nil {
3079		if err := validateVirtualRouterListeners(v.Listeners); err != nil {
3080			invalidParams.AddNested("Listeners", err.(smithy.InvalidParamsError))
3081		}
3082	}
3083	if invalidParams.Len() > 0 {
3084		return invalidParams
3085	} else {
3086		return nil
3087	}
3088}
3089
3090func validateVirtualServiceBackend(v *types.VirtualServiceBackend) error {
3091	if v == nil {
3092		return nil
3093	}
3094	invalidParams := smithy.InvalidParamsError{Context: "VirtualServiceBackend"}
3095	if v.VirtualServiceName == nil {
3096		invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName"))
3097	}
3098	if v.ClientPolicy != nil {
3099		if err := validateClientPolicy(v.ClientPolicy); err != nil {
3100			invalidParams.AddNested("ClientPolicy", err.(smithy.InvalidParamsError))
3101		}
3102	}
3103	if invalidParams.Len() > 0 {
3104		return invalidParams
3105	} else {
3106		return nil
3107	}
3108}
3109
3110func validateVirtualServiceProvider(v types.VirtualServiceProvider) error {
3111	if v == nil {
3112		return nil
3113	}
3114	invalidParams := smithy.InvalidParamsError{Context: "VirtualServiceProvider"}
3115	switch uv := v.(type) {
3116	case *types.VirtualServiceProviderMemberVirtualNode:
3117		if err := validateVirtualNodeServiceProvider(&uv.Value); err != nil {
3118			invalidParams.AddNested("[virtualNode]", err.(smithy.InvalidParamsError))
3119		}
3120
3121	case *types.VirtualServiceProviderMemberVirtualRouter:
3122		if err := validateVirtualRouterServiceProvider(&uv.Value); err != nil {
3123			invalidParams.AddNested("[virtualRouter]", err.(smithy.InvalidParamsError))
3124		}
3125
3126	}
3127	if invalidParams.Len() > 0 {
3128		return invalidParams
3129	} else {
3130		return nil
3131	}
3132}
3133
3134func validateVirtualServiceSpec(v *types.VirtualServiceSpec) error {
3135	if v == nil {
3136		return nil
3137	}
3138	invalidParams := smithy.InvalidParamsError{Context: "VirtualServiceSpec"}
3139	if v.Provider != nil {
3140		if err := validateVirtualServiceProvider(v.Provider); err != nil {
3141			invalidParams.AddNested("Provider", err.(smithy.InvalidParamsError))
3142		}
3143	}
3144	if invalidParams.Len() > 0 {
3145		return invalidParams
3146	} else {
3147		return nil
3148	}
3149}
3150
3151func validateWeightedTarget(v *types.WeightedTarget) error {
3152	if v == nil {
3153		return nil
3154	}
3155	invalidParams := smithy.InvalidParamsError{Context: "WeightedTarget"}
3156	if v.VirtualNode == nil {
3157		invalidParams.Add(smithy.NewErrParamRequired("VirtualNode"))
3158	}
3159	if invalidParams.Len() > 0 {
3160		return invalidParams
3161	} else {
3162		return nil
3163	}
3164}
3165
3166func validateWeightedTargets(v []types.WeightedTarget) error {
3167	if v == nil {
3168		return nil
3169	}
3170	invalidParams := smithy.InvalidParamsError{Context: "WeightedTargets"}
3171	for i := range v {
3172		if err := validateWeightedTarget(&v[i]); err != nil {
3173			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
3174		}
3175	}
3176	if invalidParams.Len() > 0 {
3177		return invalidParams
3178	} else {
3179		return nil
3180	}
3181}
3182
3183func validateOpCreateGatewayRouteInput(v *CreateGatewayRouteInput) error {
3184	if v == nil {
3185		return nil
3186	}
3187	invalidParams := smithy.InvalidParamsError{Context: "CreateGatewayRouteInput"}
3188	if v.GatewayRouteName == nil {
3189		invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName"))
3190	}
3191	if v.MeshName == nil {
3192		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3193	}
3194	if v.VirtualGatewayName == nil {
3195		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
3196	}
3197	if v.Spec == nil {
3198		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3199	} else if v.Spec != nil {
3200		if err := validateGatewayRouteSpec(v.Spec); err != nil {
3201			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3202		}
3203	}
3204	if v.Tags != nil {
3205		if err := validateTagList(v.Tags); err != nil {
3206			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
3207		}
3208	}
3209	if invalidParams.Len() > 0 {
3210		return invalidParams
3211	} else {
3212		return nil
3213	}
3214}
3215
3216func validateOpCreateMeshInput(v *CreateMeshInput) error {
3217	if v == nil {
3218		return nil
3219	}
3220	invalidParams := smithy.InvalidParamsError{Context: "CreateMeshInput"}
3221	if v.MeshName == nil {
3222		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3223	}
3224	if v.Spec != nil {
3225		if err := validateMeshSpec(v.Spec); err != nil {
3226			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3227		}
3228	}
3229	if v.Tags != nil {
3230		if err := validateTagList(v.Tags); err != nil {
3231			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
3232		}
3233	}
3234	if invalidParams.Len() > 0 {
3235		return invalidParams
3236	} else {
3237		return nil
3238	}
3239}
3240
3241func validateOpCreateRouteInput(v *CreateRouteInput) error {
3242	if v == nil {
3243		return nil
3244	}
3245	invalidParams := smithy.InvalidParamsError{Context: "CreateRouteInput"}
3246	if v.RouteName == nil {
3247		invalidParams.Add(smithy.NewErrParamRequired("RouteName"))
3248	}
3249	if v.MeshName == nil {
3250		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3251	}
3252	if v.VirtualRouterName == nil {
3253		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
3254	}
3255	if v.Spec == nil {
3256		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3257	} else if v.Spec != nil {
3258		if err := validateRouteSpec(v.Spec); err != nil {
3259			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3260		}
3261	}
3262	if v.Tags != nil {
3263		if err := validateTagList(v.Tags); err != nil {
3264			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
3265		}
3266	}
3267	if invalidParams.Len() > 0 {
3268		return invalidParams
3269	} else {
3270		return nil
3271	}
3272}
3273
3274func validateOpCreateVirtualGatewayInput(v *CreateVirtualGatewayInput) error {
3275	if v == nil {
3276		return nil
3277	}
3278	invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualGatewayInput"}
3279	if v.VirtualGatewayName == nil {
3280		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
3281	}
3282	if v.MeshName == nil {
3283		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3284	}
3285	if v.Spec == nil {
3286		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3287	} else if v.Spec != nil {
3288		if err := validateVirtualGatewaySpec(v.Spec); err != nil {
3289			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3290		}
3291	}
3292	if v.Tags != nil {
3293		if err := validateTagList(v.Tags); err != nil {
3294			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
3295		}
3296	}
3297	if invalidParams.Len() > 0 {
3298		return invalidParams
3299	} else {
3300		return nil
3301	}
3302}
3303
3304func validateOpCreateVirtualNodeInput(v *CreateVirtualNodeInput) error {
3305	if v == nil {
3306		return nil
3307	}
3308	invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualNodeInput"}
3309	if v.VirtualNodeName == nil {
3310		invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName"))
3311	}
3312	if v.MeshName == nil {
3313		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3314	}
3315	if v.Spec == nil {
3316		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3317	} else if v.Spec != nil {
3318		if err := validateVirtualNodeSpec(v.Spec); err != nil {
3319			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3320		}
3321	}
3322	if v.Tags != nil {
3323		if err := validateTagList(v.Tags); err != nil {
3324			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
3325		}
3326	}
3327	if invalidParams.Len() > 0 {
3328		return invalidParams
3329	} else {
3330		return nil
3331	}
3332}
3333
3334func validateOpCreateVirtualRouterInput(v *CreateVirtualRouterInput) error {
3335	if v == nil {
3336		return nil
3337	}
3338	invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualRouterInput"}
3339	if v.VirtualRouterName == nil {
3340		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
3341	}
3342	if v.MeshName == nil {
3343		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3344	}
3345	if v.Spec == nil {
3346		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3347	} else if v.Spec != nil {
3348		if err := validateVirtualRouterSpec(v.Spec); err != nil {
3349			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3350		}
3351	}
3352	if v.Tags != nil {
3353		if err := validateTagList(v.Tags); err != nil {
3354			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
3355		}
3356	}
3357	if invalidParams.Len() > 0 {
3358		return invalidParams
3359	} else {
3360		return nil
3361	}
3362}
3363
3364func validateOpCreateVirtualServiceInput(v *CreateVirtualServiceInput) error {
3365	if v == nil {
3366		return nil
3367	}
3368	invalidParams := smithy.InvalidParamsError{Context: "CreateVirtualServiceInput"}
3369	if v.VirtualServiceName == nil {
3370		invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName"))
3371	}
3372	if v.MeshName == nil {
3373		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3374	}
3375	if v.Spec == nil {
3376		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3377	} else if v.Spec != nil {
3378		if err := validateVirtualServiceSpec(v.Spec); err != nil {
3379			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3380		}
3381	}
3382	if v.Tags != nil {
3383		if err := validateTagList(v.Tags); err != nil {
3384			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
3385		}
3386	}
3387	if invalidParams.Len() > 0 {
3388		return invalidParams
3389	} else {
3390		return nil
3391	}
3392}
3393
3394func validateOpDeleteGatewayRouteInput(v *DeleteGatewayRouteInput) error {
3395	if v == nil {
3396		return nil
3397	}
3398	invalidParams := smithy.InvalidParamsError{Context: "DeleteGatewayRouteInput"}
3399	if v.GatewayRouteName == nil {
3400		invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName"))
3401	}
3402	if v.MeshName == nil {
3403		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3404	}
3405	if v.VirtualGatewayName == nil {
3406		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
3407	}
3408	if invalidParams.Len() > 0 {
3409		return invalidParams
3410	} else {
3411		return nil
3412	}
3413}
3414
3415func validateOpDeleteMeshInput(v *DeleteMeshInput) error {
3416	if v == nil {
3417		return nil
3418	}
3419	invalidParams := smithy.InvalidParamsError{Context: "DeleteMeshInput"}
3420	if v.MeshName == nil {
3421		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3422	}
3423	if invalidParams.Len() > 0 {
3424		return invalidParams
3425	} else {
3426		return nil
3427	}
3428}
3429
3430func validateOpDeleteRouteInput(v *DeleteRouteInput) error {
3431	if v == nil {
3432		return nil
3433	}
3434	invalidParams := smithy.InvalidParamsError{Context: "DeleteRouteInput"}
3435	if v.RouteName == nil {
3436		invalidParams.Add(smithy.NewErrParamRequired("RouteName"))
3437	}
3438	if v.MeshName == nil {
3439		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3440	}
3441	if v.VirtualRouterName == nil {
3442		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
3443	}
3444	if invalidParams.Len() > 0 {
3445		return invalidParams
3446	} else {
3447		return nil
3448	}
3449}
3450
3451func validateOpDeleteVirtualGatewayInput(v *DeleteVirtualGatewayInput) error {
3452	if v == nil {
3453		return nil
3454	}
3455	invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualGatewayInput"}
3456	if v.VirtualGatewayName == nil {
3457		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
3458	}
3459	if v.MeshName == nil {
3460		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3461	}
3462	if invalidParams.Len() > 0 {
3463		return invalidParams
3464	} else {
3465		return nil
3466	}
3467}
3468
3469func validateOpDeleteVirtualNodeInput(v *DeleteVirtualNodeInput) error {
3470	if v == nil {
3471		return nil
3472	}
3473	invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualNodeInput"}
3474	if v.VirtualNodeName == nil {
3475		invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName"))
3476	}
3477	if v.MeshName == nil {
3478		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3479	}
3480	if invalidParams.Len() > 0 {
3481		return invalidParams
3482	} else {
3483		return nil
3484	}
3485}
3486
3487func validateOpDeleteVirtualRouterInput(v *DeleteVirtualRouterInput) error {
3488	if v == nil {
3489		return nil
3490	}
3491	invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualRouterInput"}
3492	if v.VirtualRouterName == nil {
3493		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
3494	}
3495	if v.MeshName == nil {
3496		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3497	}
3498	if invalidParams.Len() > 0 {
3499		return invalidParams
3500	} else {
3501		return nil
3502	}
3503}
3504
3505func validateOpDeleteVirtualServiceInput(v *DeleteVirtualServiceInput) error {
3506	if v == nil {
3507		return nil
3508	}
3509	invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualServiceInput"}
3510	if v.VirtualServiceName == nil {
3511		invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName"))
3512	}
3513	if v.MeshName == nil {
3514		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3515	}
3516	if invalidParams.Len() > 0 {
3517		return invalidParams
3518	} else {
3519		return nil
3520	}
3521}
3522
3523func validateOpDescribeGatewayRouteInput(v *DescribeGatewayRouteInput) error {
3524	if v == nil {
3525		return nil
3526	}
3527	invalidParams := smithy.InvalidParamsError{Context: "DescribeGatewayRouteInput"}
3528	if v.GatewayRouteName == nil {
3529		invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName"))
3530	}
3531	if v.MeshName == nil {
3532		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3533	}
3534	if v.VirtualGatewayName == nil {
3535		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
3536	}
3537	if invalidParams.Len() > 0 {
3538		return invalidParams
3539	} else {
3540		return nil
3541	}
3542}
3543
3544func validateOpDescribeMeshInput(v *DescribeMeshInput) error {
3545	if v == nil {
3546		return nil
3547	}
3548	invalidParams := smithy.InvalidParamsError{Context: "DescribeMeshInput"}
3549	if v.MeshName == nil {
3550		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3551	}
3552	if invalidParams.Len() > 0 {
3553		return invalidParams
3554	} else {
3555		return nil
3556	}
3557}
3558
3559func validateOpDescribeRouteInput(v *DescribeRouteInput) error {
3560	if v == nil {
3561		return nil
3562	}
3563	invalidParams := smithy.InvalidParamsError{Context: "DescribeRouteInput"}
3564	if v.RouteName == nil {
3565		invalidParams.Add(smithy.NewErrParamRequired("RouteName"))
3566	}
3567	if v.MeshName == nil {
3568		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3569	}
3570	if v.VirtualRouterName == nil {
3571		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
3572	}
3573	if invalidParams.Len() > 0 {
3574		return invalidParams
3575	} else {
3576		return nil
3577	}
3578}
3579
3580func validateOpDescribeVirtualGatewayInput(v *DescribeVirtualGatewayInput) error {
3581	if v == nil {
3582		return nil
3583	}
3584	invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualGatewayInput"}
3585	if v.VirtualGatewayName == nil {
3586		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
3587	}
3588	if v.MeshName == nil {
3589		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3590	}
3591	if invalidParams.Len() > 0 {
3592		return invalidParams
3593	} else {
3594		return nil
3595	}
3596}
3597
3598func validateOpDescribeVirtualNodeInput(v *DescribeVirtualNodeInput) error {
3599	if v == nil {
3600		return nil
3601	}
3602	invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualNodeInput"}
3603	if v.VirtualNodeName == nil {
3604		invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName"))
3605	}
3606	if v.MeshName == nil {
3607		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3608	}
3609	if invalidParams.Len() > 0 {
3610		return invalidParams
3611	} else {
3612		return nil
3613	}
3614}
3615
3616func validateOpDescribeVirtualRouterInput(v *DescribeVirtualRouterInput) error {
3617	if v == nil {
3618		return nil
3619	}
3620	invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualRouterInput"}
3621	if v.VirtualRouterName == nil {
3622		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
3623	}
3624	if v.MeshName == nil {
3625		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3626	}
3627	if invalidParams.Len() > 0 {
3628		return invalidParams
3629	} else {
3630		return nil
3631	}
3632}
3633
3634func validateOpDescribeVirtualServiceInput(v *DescribeVirtualServiceInput) error {
3635	if v == nil {
3636		return nil
3637	}
3638	invalidParams := smithy.InvalidParamsError{Context: "DescribeVirtualServiceInput"}
3639	if v.VirtualServiceName == nil {
3640		invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName"))
3641	}
3642	if v.MeshName == nil {
3643		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3644	}
3645	if invalidParams.Len() > 0 {
3646		return invalidParams
3647	} else {
3648		return nil
3649	}
3650}
3651
3652func validateOpListGatewayRoutesInput(v *ListGatewayRoutesInput) error {
3653	if v == nil {
3654		return nil
3655	}
3656	invalidParams := smithy.InvalidParamsError{Context: "ListGatewayRoutesInput"}
3657	if v.MeshName == nil {
3658		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3659	}
3660	if v.VirtualGatewayName == nil {
3661		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
3662	}
3663	if invalidParams.Len() > 0 {
3664		return invalidParams
3665	} else {
3666		return nil
3667	}
3668}
3669
3670func validateOpListRoutesInput(v *ListRoutesInput) error {
3671	if v == nil {
3672		return nil
3673	}
3674	invalidParams := smithy.InvalidParamsError{Context: "ListRoutesInput"}
3675	if v.MeshName == nil {
3676		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3677	}
3678	if v.VirtualRouterName == nil {
3679		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
3680	}
3681	if invalidParams.Len() > 0 {
3682		return invalidParams
3683	} else {
3684		return nil
3685	}
3686}
3687
3688func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
3689	if v == nil {
3690		return nil
3691	}
3692	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
3693	if v.ResourceArn == nil {
3694		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
3695	}
3696	if invalidParams.Len() > 0 {
3697		return invalidParams
3698	} else {
3699		return nil
3700	}
3701}
3702
3703func validateOpListVirtualGatewaysInput(v *ListVirtualGatewaysInput) error {
3704	if v == nil {
3705		return nil
3706	}
3707	invalidParams := smithy.InvalidParamsError{Context: "ListVirtualGatewaysInput"}
3708	if v.MeshName == nil {
3709		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3710	}
3711	if invalidParams.Len() > 0 {
3712		return invalidParams
3713	} else {
3714		return nil
3715	}
3716}
3717
3718func validateOpListVirtualNodesInput(v *ListVirtualNodesInput) error {
3719	if v == nil {
3720		return nil
3721	}
3722	invalidParams := smithy.InvalidParamsError{Context: "ListVirtualNodesInput"}
3723	if v.MeshName == nil {
3724		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3725	}
3726	if invalidParams.Len() > 0 {
3727		return invalidParams
3728	} else {
3729		return nil
3730	}
3731}
3732
3733func validateOpListVirtualRoutersInput(v *ListVirtualRoutersInput) error {
3734	if v == nil {
3735		return nil
3736	}
3737	invalidParams := smithy.InvalidParamsError{Context: "ListVirtualRoutersInput"}
3738	if v.MeshName == nil {
3739		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3740	}
3741	if invalidParams.Len() > 0 {
3742		return invalidParams
3743	} else {
3744		return nil
3745	}
3746}
3747
3748func validateOpListVirtualServicesInput(v *ListVirtualServicesInput) error {
3749	if v == nil {
3750		return nil
3751	}
3752	invalidParams := smithy.InvalidParamsError{Context: "ListVirtualServicesInput"}
3753	if v.MeshName == nil {
3754		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3755	}
3756	if invalidParams.Len() > 0 {
3757		return invalidParams
3758	} else {
3759		return nil
3760	}
3761}
3762
3763func validateOpTagResourceInput(v *TagResourceInput) error {
3764	if v == nil {
3765		return nil
3766	}
3767	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
3768	if v.ResourceArn == nil {
3769		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
3770	}
3771	if v.Tags == nil {
3772		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
3773	} else if v.Tags != nil {
3774		if err := validateTagList(v.Tags); err != nil {
3775			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
3776		}
3777	}
3778	if invalidParams.Len() > 0 {
3779		return invalidParams
3780	} else {
3781		return nil
3782	}
3783}
3784
3785func validateOpUntagResourceInput(v *UntagResourceInput) error {
3786	if v == nil {
3787		return nil
3788	}
3789	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
3790	if v.ResourceArn == nil {
3791		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
3792	}
3793	if v.TagKeys == nil {
3794		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
3795	}
3796	if invalidParams.Len() > 0 {
3797		return invalidParams
3798	} else {
3799		return nil
3800	}
3801}
3802
3803func validateOpUpdateGatewayRouteInput(v *UpdateGatewayRouteInput) error {
3804	if v == nil {
3805		return nil
3806	}
3807	invalidParams := smithy.InvalidParamsError{Context: "UpdateGatewayRouteInput"}
3808	if v.GatewayRouteName == nil {
3809		invalidParams.Add(smithy.NewErrParamRequired("GatewayRouteName"))
3810	}
3811	if v.MeshName == nil {
3812		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3813	}
3814	if v.VirtualGatewayName == nil {
3815		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
3816	}
3817	if v.Spec == nil {
3818		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3819	} else if v.Spec != nil {
3820		if err := validateGatewayRouteSpec(v.Spec); err != nil {
3821			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3822		}
3823	}
3824	if invalidParams.Len() > 0 {
3825		return invalidParams
3826	} else {
3827		return nil
3828	}
3829}
3830
3831func validateOpUpdateMeshInput(v *UpdateMeshInput) error {
3832	if v == nil {
3833		return nil
3834	}
3835	invalidParams := smithy.InvalidParamsError{Context: "UpdateMeshInput"}
3836	if v.MeshName == nil {
3837		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3838	}
3839	if v.Spec != nil {
3840		if err := validateMeshSpec(v.Spec); err != nil {
3841			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3842		}
3843	}
3844	if invalidParams.Len() > 0 {
3845		return invalidParams
3846	} else {
3847		return nil
3848	}
3849}
3850
3851func validateOpUpdateRouteInput(v *UpdateRouteInput) error {
3852	if v == nil {
3853		return nil
3854	}
3855	invalidParams := smithy.InvalidParamsError{Context: "UpdateRouteInput"}
3856	if v.RouteName == nil {
3857		invalidParams.Add(smithy.NewErrParamRequired("RouteName"))
3858	}
3859	if v.MeshName == nil {
3860		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3861	}
3862	if v.VirtualRouterName == nil {
3863		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
3864	}
3865	if v.Spec == nil {
3866		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3867	} else if v.Spec != nil {
3868		if err := validateRouteSpec(v.Spec); err != nil {
3869			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3870		}
3871	}
3872	if invalidParams.Len() > 0 {
3873		return invalidParams
3874	} else {
3875		return nil
3876	}
3877}
3878
3879func validateOpUpdateVirtualGatewayInput(v *UpdateVirtualGatewayInput) error {
3880	if v == nil {
3881		return nil
3882	}
3883	invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualGatewayInput"}
3884	if v.VirtualGatewayName == nil {
3885		invalidParams.Add(smithy.NewErrParamRequired("VirtualGatewayName"))
3886	}
3887	if v.MeshName == nil {
3888		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3889	}
3890	if v.Spec == nil {
3891		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3892	} else if v.Spec != nil {
3893		if err := validateVirtualGatewaySpec(v.Spec); err != nil {
3894			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3895		}
3896	}
3897	if invalidParams.Len() > 0 {
3898		return invalidParams
3899	} else {
3900		return nil
3901	}
3902}
3903
3904func validateOpUpdateVirtualNodeInput(v *UpdateVirtualNodeInput) error {
3905	if v == nil {
3906		return nil
3907	}
3908	invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualNodeInput"}
3909	if v.VirtualNodeName == nil {
3910		invalidParams.Add(smithy.NewErrParamRequired("VirtualNodeName"))
3911	}
3912	if v.MeshName == nil {
3913		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3914	}
3915	if v.Spec == nil {
3916		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3917	} else if v.Spec != nil {
3918		if err := validateVirtualNodeSpec(v.Spec); err != nil {
3919			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3920		}
3921	}
3922	if invalidParams.Len() > 0 {
3923		return invalidParams
3924	} else {
3925		return nil
3926	}
3927}
3928
3929func validateOpUpdateVirtualRouterInput(v *UpdateVirtualRouterInput) error {
3930	if v == nil {
3931		return nil
3932	}
3933	invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualRouterInput"}
3934	if v.VirtualRouterName == nil {
3935		invalidParams.Add(smithy.NewErrParamRequired("VirtualRouterName"))
3936	}
3937	if v.MeshName == nil {
3938		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3939	}
3940	if v.Spec == nil {
3941		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3942	} else if v.Spec != nil {
3943		if err := validateVirtualRouterSpec(v.Spec); err != nil {
3944			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3945		}
3946	}
3947	if invalidParams.Len() > 0 {
3948		return invalidParams
3949	} else {
3950		return nil
3951	}
3952}
3953
3954func validateOpUpdateVirtualServiceInput(v *UpdateVirtualServiceInput) error {
3955	if v == nil {
3956		return nil
3957	}
3958	invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualServiceInput"}
3959	if v.VirtualServiceName == nil {
3960		invalidParams.Add(smithy.NewErrParamRequired("VirtualServiceName"))
3961	}
3962	if v.MeshName == nil {
3963		invalidParams.Add(smithy.NewErrParamRequired("MeshName"))
3964	}
3965	if v.Spec == nil {
3966		invalidParams.Add(smithy.NewErrParamRequired("Spec"))
3967	} else if v.Spec != nil {
3968		if err := validateVirtualServiceSpec(v.Spec); err != nil {
3969			invalidParams.AddNested("Spec", err.(smithy.InvalidParamsError))
3970		}
3971	}
3972	if invalidParams.Len() > 0 {
3973		return invalidParams
3974	} else {
3975		return nil
3976	}
3977}
3978