1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package directconnect
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/directconnect/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAcceptDirectConnectGatewayAssociationProposal struct {
14}
15
16func (*validateOpAcceptDirectConnectGatewayAssociationProposal) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAcceptDirectConnectGatewayAssociationProposal) 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.(*AcceptDirectConnectGatewayAssociationProposalInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAcceptDirectConnectGatewayAssociationProposalInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpAllocateConnectionOnInterconnect struct {
34}
35
36func (*validateOpAllocateConnectionOnInterconnect) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpAllocateConnectionOnInterconnect) 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.(*AllocateConnectionOnInterconnectInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpAllocateConnectionOnInterconnectInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpAllocateHostedConnection struct {
54}
55
56func (*validateOpAllocateHostedConnection) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpAllocateHostedConnection) 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.(*AllocateHostedConnectionInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpAllocateHostedConnectionInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpAllocatePrivateVirtualInterface struct {
74}
75
76func (*validateOpAllocatePrivateVirtualInterface) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpAllocatePrivateVirtualInterface) 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.(*AllocatePrivateVirtualInterfaceInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpAllocatePrivateVirtualInterfaceInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpAllocatePublicVirtualInterface struct {
94}
95
96func (*validateOpAllocatePublicVirtualInterface) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpAllocatePublicVirtualInterface) 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.(*AllocatePublicVirtualInterfaceInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpAllocatePublicVirtualInterfaceInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpAllocateTransitVirtualInterface struct {
114}
115
116func (*validateOpAllocateTransitVirtualInterface) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpAllocateTransitVirtualInterface) 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.(*AllocateTransitVirtualInterfaceInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpAllocateTransitVirtualInterfaceInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpAssociateConnectionWithLag struct {
134}
135
136func (*validateOpAssociateConnectionWithLag) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpAssociateConnectionWithLag) 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.(*AssociateConnectionWithLagInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpAssociateConnectionWithLagInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpAssociateHostedConnection struct {
154}
155
156func (*validateOpAssociateHostedConnection) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpAssociateHostedConnection) 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.(*AssociateHostedConnectionInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpAssociateHostedConnectionInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpAssociateMacSecKey struct {
174}
175
176func (*validateOpAssociateMacSecKey) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpAssociateMacSecKey) 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.(*AssociateMacSecKeyInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpAssociateMacSecKeyInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpAssociateVirtualInterface struct {
194}
195
196func (*validateOpAssociateVirtualInterface) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpAssociateVirtualInterface) 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.(*AssociateVirtualInterfaceInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpAssociateVirtualInterfaceInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpConfirmConnection struct {
214}
215
216func (*validateOpConfirmConnection) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpConfirmConnection) 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.(*ConfirmConnectionInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpConfirmConnectionInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpConfirmPrivateVirtualInterface struct {
234}
235
236func (*validateOpConfirmPrivateVirtualInterface) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpConfirmPrivateVirtualInterface) 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.(*ConfirmPrivateVirtualInterfaceInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpConfirmPrivateVirtualInterfaceInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpConfirmPublicVirtualInterface struct {
254}
255
256func (*validateOpConfirmPublicVirtualInterface) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpConfirmPublicVirtualInterface) 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.(*ConfirmPublicVirtualInterfaceInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpConfirmPublicVirtualInterfaceInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpConfirmTransitVirtualInterface struct {
274}
275
276func (*validateOpConfirmTransitVirtualInterface) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpConfirmTransitVirtualInterface) 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.(*ConfirmTransitVirtualInterfaceInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpConfirmTransitVirtualInterfaceInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpCreateConnection struct {
294}
295
296func (*validateOpCreateConnection) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpCreateConnection) 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.(*CreateConnectionInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpCreateConnectionInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpCreateDirectConnectGatewayAssociation struct {
314}
315
316func (*validateOpCreateDirectConnectGatewayAssociation) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpCreateDirectConnectGatewayAssociation) 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.(*CreateDirectConnectGatewayAssociationInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpCreateDirectConnectGatewayAssociationInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpCreateDirectConnectGatewayAssociationProposal struct {
334}
335
336func (*validateOpCreateDirectConnectGatewayAssociationProposal) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpCreateDirectConnectGatewayAssociationProposal) 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.(*CreateDirectConnectGatewayAssociationProposalInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpCreateDirectConnectGatewayAssociationProposalInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpCreateDirectConnectGateway struct {
354}
355
356func (*validateOpCreateDirectConnectGateway) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpCreateDirectConnectGateway) 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.(*CreateDirectConnectGatewayInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpCreateDirectConnectGatewayInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpCreateInterconnect struct {
374}
375
376func (*validateOpCreateInterconnect) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpCreateInterconnect) 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.(*CreateInterconnectInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpCreateInterconnectInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpCreateLag struct {
394}
395
396func (*validateOpCreateLag) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpCreateLag) 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.(*CreateLagInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpCreateLagInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpCreatePrivateVirtualInterface struct {
414}
415
416func (*validateOpCreatePrivateVirtualInterface) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpCreatePrivateVirtualInterface) 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.(*CreatePrivateVirtualInterfaceInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpCreatePrivateVirtualInterfaceInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpCreatePublicVirtualInterface struct {
434}
435
436func (*validateOpCreatePublicVirtualInterface) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpCreatePublicVirtualInterface) 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.(*CreatePublicVirtualInterfaceInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpCreatePublicVirtualInterfaceInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpCreateTransitVirtualInterface struct {
454}
455
456func (*validateOpCreateTransitVirtualInterface) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpCreateTransitVirtualInterface) 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.(*CreateTransitVirtualInterfaceInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpCreateTransitVirtualInterfaceInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpDeleteConnection struct {
474}
475
476func (*validateOpDeleteConnection) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpDeleteConnection) 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.(*DeleteConnectionInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpDeleteConnectionInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpDeleteDirectConnectGatewayAssociationProposal struct {
494}
495
496func (*validateOpDeleteDirectConnectGatewayAssociationProposal) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpDeleteDirectConnectGatewayAssociationProposal) 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.(*DeleteDirectConnectGatewayAssociationProposalInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpDeleteDirectConnectGatewayAssociationProposalInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpDeleteDirectConnectGateway struct {
514}
515
516func (*validateOpDeleteDirectConnectGateway) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpDeleteDirectConnectGateway) 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.(*DeleteDirectConnectGatewayInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpDeleteDirectConnectGatewayInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpDeleteInterconnect struct {
534}
535
536func (*validateOpDeleteInterconnect) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpDeleteInterconnect) 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.(*DeleteInterconnectInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpDeleteInterconnectInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpDeleteLag struct {
554}
555
556func (*validateOpDeleteLag) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpDeleteLag) 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.(*DeleteLagInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpDeleteLagInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpDeleteVirtualInterface struct {
574}
575
576func (*validateOpDeleteVirtualInterface) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpDeleteVirtualInterface) 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.(*DeleteVirtualInterfaceInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpDeleteVirtualInterfaceInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpDescribeConnectionLoa struct {
594}
595
596func (*validateOpDescribeConnectionLoa) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpDescribeConnectionLoa) 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.(*DescribeConnectionLoaInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpDescribeConnectionLoaInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpDescribeConnectionsOnInterconnect struct {
614}
615
616func (*validateOpDescribeConnectionsOnInterconnect) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpDescribeConnectionsOnInterconnect) 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.(*DescribeConnectionsOnInterconnectInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpDescribeConnectionsOnInterconnectInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpDescribeHostedConnections struct {
634}
635
636func (*validateOpDescribeHostedConnections) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpDescribeHostedConnections) 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.(*DescribeHostedConnectionsInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpDescribeHostedConnectionsInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpDescribeInterconnectLoa struct {
654}
655
656func (*validateOpDescribeInterconnectLoa) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpDescribeInterconnectLoa) 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.(*DescribeInterconnectLoaInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpDescribeInterconnectLoaInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpDescribeLoa struct {
674}
675
676func (*validateOpDescribeLoa) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpDescribeLoa) 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.(*DescribeLoaInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpDescribeLoaInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpDescribeTags struct {
694}
695
696func (*validateOpDescribeTags) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpDescribeTags) 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.(*DescribeTagsInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpDescribeTagsInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpDisassociateConnectionFromLag struct {
714}
715
716func (*validateOpDisassociateConnectionFromLag) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpDisassociateConnectionFromLag) 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.(*DisassociateConnectionFromLagInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpDisassociateConnectionFromLagInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpDisassociateMacSecKey struct {
734}
735
736func (*validateOpDisassociateMacSecKey) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpDisassociateMacSecKey) 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.(*DisassociateMacSecKeyInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpDisassociateMacSecKeyInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpStartBgpFailoverTest struct {
754}
755
756func (*validateOpStartBgpFailoverTest) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpStartBgpFailoverTest) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
761	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
762) {
763	input, ok := in.Parameters.(*StartBgpFailoverTestInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpStartBgpFailoverTestInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpStopBgpFailoverTest struct {
774}
775
776func (*validateOpStopBgpFailoverTest) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpStopBgpFailoverTest) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
781	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
782) {
783	input, ok := in.Parameters.(*StopBgpFailoverTestInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpStopBgpFailoverTestInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpTagResource struct {
794}
795
796func (*validateOpTagResource) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
801	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
802) {
803	input, ok := in.Parameters.(*TagResourceInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpTagResourceInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpUntagResource struct {
814}
815
816func (*validateOpUntagResource) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
821	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
822) {
823	input, ok := in.Parameters.(*UntagResourceInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpUntagResourceInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpUpdateConnection struct {
834}
835
836func (*validateOpUpdateConnection) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpUpdateConnection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
841	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
842) {
843	input, ok := in.Parameters.(*UpdateConnectionInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpUpdateConnectionInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpUpdateLag struct {
854}
855
856func (*validateOpUpdateLag) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpUpdateLag) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
861	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
862) {
863	input, ok := in.Parameters.(*UpdateLagInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpUpdateLagInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpUpdateVirtualInterfaceAttributes struct {
874}
875
876func (*validateOpUpdateVirtualInterfaceAttributes) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpUpdateVirtualInterfaceAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
881	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
882) {
883	input, ok := in.Parameters.(*UpdateVirtualInterfaceAttributesInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpUpdateVirtualInterfaceAttributesInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893func addOpAcceptDirectConnectGatewayAssociationProposalValidationMiddleware(stack *middleware.Stack) error {
894	return stack.Initialize.Add(&validateOpAcceptDirectConnectGatewayAssociationProposal{}, middleware.After)
895}
896
897func addOpAllocateConnectionOnInterconnectValidationMiddleware(stack *middleware.Stack) error {
898	return stack.Initialize.Add(&validateOpAllocateConnectionOnInterconnect{}, middleware.After)
899}
900
901func addOpAllocateHostedConnectionValidationMiddleware(stack *middleware.Stack) error {
902	return stack.Initialize.Add(&validateOpAllocateHostedConnection{}, middleware.After)
903}
904
905func addOpAllocatePrivateVirtualInterfaceValidationMiddleware(stack *middleware.Stack) error {
906	return stack.Initialize.Add(&validateOpAllocatePrivateVirtualInterface{}, middleware.After)
907}
908
909func addOpAllocatePublicVirtualInterfaceValidationMiddleware(stack *middleware.Stack) error {
910	return stack.Initialize.Add(&validateOpAllocatePublicVirtualInterface{}, middleware.After)
911}
912
913func addOpAllocateTransitVirtualInterfaceValidationMiddleware(stack *middleware.Stack) error {
914	return stack.Initialize.Add(&validateOpAllocateTransitVirtualInterface{}, middleware.After)
915}
916
917func addOpAssociateConnectionWithLagValidationMiddleware(stack *middleware.Stack) error {
918	return stack.Initialize.Add(&validateOpAssociateConnectionWithLag{}, middleware.After)
919}
920
921func addOpAssociateHostedConnectionValidationMiddleware(stack *middleware.Stack) error {
922	return stack.Initialize.Add(&validateOpAssociateHostedConnection{}, middleware.After)
923}
924
925func addOpAssociateMacSecKeyValidationMiddleware(stack *middleware.Stack) error {
926	return stack.Initialize.Add(&validateOpAssociateMacSecKey{}, middleware.After)
927}
928
929func addOpAssociateVirtualInterfaceValidationMiddleware(stack *middleware.Stack) error {
930	return stack.Initialize.Add(&validateOpAssociateVirtualInterface{}, middleware.After)
931}
932
933func addOpConfirmConnectionValidationMiddleware(stack *middleware.Stack) error {
934	return stack.Initialize.Add(&validateOpConfirmConnection{}, middleware.After)
935}
936
937func addOpConfirmPrivateVirtualInterfaceValidationMiddleware(stack *middleware.Stack) error {
938	return stack.Initialize.Add(&validateOpConfirmPrivateVirtualInterface{}, middleware.After)
939}
940
941func addOpConfirmPublicVirtualInterfaceValidationMiddleware(stack *middleware.Stack) error {
942	return stack.Initialize.Add(&validateOpConfirmPublicVirtualInterface{}, middleware.After)
943}
944
945func addOpConfirmTransitVirtualInterfaceValidationMiddleware(stack *middleware.Stack) error {
946	return stack.Initialize.Add(&validateOpConfirmTransitVirtualInterface{}, middleware.After)
947}
948
949func addOpCreateConnectionValidationMiddleware(stack *middleware.Stack) error {
950	return stack.Initialize.Add(&validateOpCreateConnection{}, middleware.After)
951}
952
953func addOpCreateDirectConnectGatewayAssociationValidationMiddleware(stack *middleware.Stack) error {
954	return stack.Initialize.Add(&validateOpCreateDirectConnectGatewayAssociation{}, middleware.After)
955}
956
957func addOpCreateDirectConnectGatewayAssociationProposalValidationMiddleware(stack *middleware.Stack) error {
958	return stack.Initialize.Add(&validateOpCreateDirectConnectGatewayAssociationProposal{}, middleware.After)
959}
960
961func addOpCreateDirectConnectGatewayValidationMiddleware(stack *middleware.Stack) error {
962	return stack.Initialize.Add(&validateOpCreateDirectConnectGateway{}, middleware.After)
963}
964
965func addOpCreateInterconnectValidationMiddleware(stack *middleware.Stack) error {
966	return stack.Initialize.Add(&validateOpCreateInterconnect{}, middleware.After)
967}
968
969func addOpCreateLagValidationMiddleware(stack *middleware.Stack) error {
970	return stack.Initialize.Add(&validateOpCreateLag{}, middleware.After)
971}
972
973func addOpCreatePrivateVirtualInterfaceValidationMiddleware(stack *middleware.Stack) error {
974	return stack.Initialize.Add(&validateOpCreatePrivateVirtualInterface{}, middleware.After)
975}
976
977func addOpCreatePublicVirtualInterfaceValidationMiddleware(stack *middleware.Stack) error {
978	return stack.Initialize.Add(&validateOpCreatePublicVirtualInterface{}, middleware.After)
979}
980
981func addOpCreateTransitVirtualInterfaceValidationMiddleware(stack *middleware.Stack) error {
982	return stack.Initialize.Add(&validateOpCreateTransitVirtualInterface{}, middleware.After)
983}
984
985func addOpDeleteConnectionValidationMiddleware(stack *middleware.Stack) error {
986	return stack.Initialize.Add(&validateOpDeleteConnection{}, middleware.After)
987}
988
989func addOpDeleteDirectConnectGatewayAssociationProposalValidationMiddleware(stack *middleware.Stack) error {
990	return stack.Initialize.Add(&validateOpDeleteDirectConnectGatewayAssociationProposal{}, middleware.After)
991}
992
993func addOpDeleteDirectConnectGatewayValidationMiddleware(stack *middleware.Stack) error {
994	return stack.Initialize.Add(&validateOpDeleteDirectConnectGateway{}, middleware.After)
995}
996
997func addOpDeleteInterconnectValidationMiddleware(stack *middleware.Stack) error {
998	return stack.Initialize.Add(&validateOpDeleteInterconnect{}, middleware.After)
999}
1000
1001func addOpDeleteLagValidationMiddleware(stack *middleware.Stack) error {
1002	return stack.Initialize.Add(&validateOpDeleteLag{}, middleware.After)
1003}
1004
1005func addOpDeleteVirtualInterfaceValidationMiddleware(stack *middleware.Stack) error {
1006	return stack.Initialize.Add(&validateOpDeleteVirtualInterface{}, middleware.After)
1007}
1008
1009func addOpDescribeConnectionLoaValidationMiddleware(stack *middleware.Stack) error {
1010	return stack.Initialize.Add(&validateOpDescribeConnectionLoa{}, middleware.After)
1011}
1012
1013func addOpDescribeConnectionsOnInterconnectValidationMiddleware(stack *middleware.Stack) error {
1014	return stack.Initialize.Add(&validateOpDescribeConnectionsOnInterconnect{}, middleware.After)
1015}
1016
1017func addOpDescribeHostedConnectionsValidationMiddleware(stack *middleware.Stack) error {
1018	return stack.Initialize.Add(&validateOpDescribeHostedConnections{}, middleware.After)
1019}
1020
1021func addOpDescribeInterconnectLoaValidationMiddleware(stack *middleware.Stack) error {
1022	return stack.Initialize.Add(&validateOpDescribeInterconnectLoa{}, middleware.After)
1023}
1024
1025func addOpDescribeLoaValidationMiddleware(stack *middleware.Stack) error {
1026	return stack.Initialize.Add(&validateOpDescribeLoa{}, middleware.After)
1027}
1028
1029func addOpDescribeTagsValidationMiddleware(stack *middleware.Stack) error {
1030	return stack.Initialize.Add(&validateOpDescribeTags{}, middleware.After)
1031}
1032
1033func addOpDisassociateConnectionFromLagValidationMiddleware(stack *middleware.Stack) error {
1034	return stack.Initialize.Add(&validateOpDisassociateConnectionFromLag{}, middleware.After)
1035}
1036
1037func addOpDisassociateMacSecKeyValidationMiddleware(stack *middleware.Stack) error {
1038	return stack.Initialize.Add(&validateOpDisassociateMacSecKey{}, middleware.After)
1039}
1040
1041func addOpStartBgpFailoverTestValidationMiddleware(stack *middleware.Stack) error {
1042	return stack.Initialize.Add(&validateOpStartBgpFailoverTest{}, middleware.After)
1043}
1044
1045func addOpStopBgpFailoverTestValidationMiddleware(stack *middleware.Stack) error {
1046	return stack.Initialize.Add(&validateOpStopBgpFailoverTest{}, middleware.After)
1047}
1048
1049func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
1050	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
1051}
1052
1053func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
1054	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
1055}
1056
1057func addOpUpdateConnectionValidationMiddleware(stack *middleware.Stack) error {
1058	return stack.Initialize.Add(&validateOpUpdateConnection{}, middleware.After)
1059}
1060
1061func addOpUpdateLagValidationMiddleware(stack *middleware.Stack) error {
1062	return stack.Initialize.Add(&validateOpUpdateLag{}, middleware.After)
1063}
1064
1065func addOpUpdateVirtualInterfaceAttributesValidationMiddleware(stack *middleware.Stack) error {
1066	return stack.Initialize.Add(&validateOpUpdateVirtualInterfaceAttributes{}, middleware.After)
1067}
1068
1069func validateNewPrivateVirtualInterface(v *types.NewPrivateVirtualInterface) error {
1070	if v == nil {
1071		return nil
1072	}
1073	invalidParams := smithy.InvalidParamsError{Context: "NewPrivateVirtualInterface"}
1074	if v.VirtualInterfaceName == nil {
1075		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceName"))
1076	}
1077	if v.Tags != nil {
1078		if err := validateTagList(v.Tags); err != nil {
1079			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1080		}
1081	}
1082	if invalidParams.Len() > 0 {
1083		return invalidParams
1084	} else {
1085		return nil
1086	}
1087}
1088
1089func validateNewPrivateVirtualInterfaceAllocation(v *types.NewPrivateVirtualInterfaceAllocation) error {
1090	if v == nil {
1091		return nil
1092	}
1093	invalidParams := smithy.InvalidParamsError{Context: "NewPrivateVirtualInterfaceAllocation"}
1094	if v.VirtualInterfaceName == nil {
1095		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceName"))
1096	}
1097	if v.Tags != nil {
1098		if err := validateTagList(v.Tags); err != nil {
1099			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1100		}
1101	}
1102	if invalidParams.Len() > 0 {
1103		return invalidParams
1104	} else {
1105		return nil
1106	}
1107}
1108
1109func validateNewPublicVirtualInterface(v *types.NewPublicVirtualInterface) error {
1110	if v == nil {
1111		return nil
1112	}
1113	invalidParams := smithy.InvalidParamsError{Context: "NewPublicVirtualInterface"}
1114	if v.VirtualInterfaceName == nil {
1115		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceName"))
1116	}
1117	if v.Tags != nil {
1118		if err := validateTagList(v.Tags); err != nil {
1119			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1120		}
1121	}
1122	if invalidParams.Len() > 0 {
1123		return invalidParams
1124	} else {
1125		return nil
1126	}
1127}
1128
1129func validateNewPublicVirtualInterfaceAllocation(v *types.NewPublicVirtualInterfaceAllocation) error {
1130	if v == nil {
1131		return nil
1132	}
1133	invalidParams := smithy.InvalidParamsError{Context: "NewPublicVirtualInterfaceAllocation"}
1134	if v.VirtualInterfaceName == nil {
1135		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceName"))
1136	}
1137	if v.Tags != nil {
1138		if err := validateTagList(v.Tags); err != nil {
1139			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1140		}
1141	}
1142	if invalidParams.Len() > 0 {
1143		return invalidParams
1144	} else {
1145		return nil
1146	}
1147}
1148
1149func validateNewTransitVirtualInterface(v *types.NewTransitVirtualInterface) error {
1150	if v == nil {
1151		return nil
1152	}
1153	invalidParams := smithy.InvalidParamsError{Context: "NewTransitVirtualInterface"}
1154	if v.Tags != nil {
1155		if err := validateTagList(v.Tags); err != nil {
1156			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1157		}
1158	}
1159	if invalidParams.Len() > 0 {
1160		return invalidParams
1161	} else {
1162		return nil
1163	}
1164}
1165
1166func validateNewTransitVirtualInterfaceAllocation(v *types.NewTransitVirtualInterfaceAllocation) error {
1167	if v == nil {
1168		return nil
1169	}
1170	invalidParams := smithy.InvalidParamsError{Context: "NewTransitVirtualInterfaceAllocation"}
1171	if v.Tags != nil {
1172		if err := validateTagList(v.Tags); err != nil {
1173			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1174		}
1175	}
1176	if invalidParams.Len() > 0 {
1177		return invalidParams
1178	} else {
1179		return nil
1180	}
1181}
1182
1183func validateTag(v *types.Tag) error {
1184	if v == nil {
1185		return nil
1186	}
1187	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
1188	if v.Key == nil {
1189		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1190	}
1191	if invalidParams.Len() > 0 {
1192		return invalidParams
1193	} else {
1194		return nil
1195	}
1196}
1197
1198func validateTagList(v []types.Tag) error {
1199	if v == nil {
1200		return nil
1201	}
1202	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
1203	for i := range v {
1204		if err := validateTag(&v[i]); err != nil {
1205			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1206		}
1207	}
1208	if invalidParams.Len() > 0 {
1209		return invalidParams
1210	} else {
1211		return nil
1212	}
1213}
1214
1215func validateOpAcceptDirectConnectGatewayAssociationProposalInput(v *AcceptDirectConnectGatewayAssociationProposalInput) error {
1216	if v == nil {
1217		return nil
1218	}
1219	invalidParams := smithy.InvalidParamsError{Context: "AcceptDirectConnectGatewayAssociationProposalInput"}
1220	if v.DirectConnectGatewayId == nil {
1221		invalidParams.Add(smithy.NewErrParamRequired("DirectConnectGatewayId"))
1222	}
1223	if v.ProposalId == nil {
1224		invalidParams.Add(smithy.NewErrParamRequired("ProposalId"))
1225	}
1226	if v.AssociatedGatewayOwnerAccount == nil {
1227		invalidParams.Add(smithy.NewErrParamRequired("AssociatedGatewayOwnerAccount"))
1228	}
1229	if invalidParams.Len() > 0 {
1230		return invalidParams
1231	} else {
1232		return nil
1233	}
1234}
1235
1236func validateOpAllocateConnectionOnInterconnectInput(v *AllocateConnectionOnInterconnectInput) error {
1237	if v == nil {
1238		return nil
1239	}
1240	invalidParams := smithy.InvalidParamsError{Context: "AllocateConnectionOnInterconnectInput"}
1241	if v.Bandwidth == nil {
1242		invalidParams.Add(smithy.NewErrParamRequired("Bandwidth"))
1243	}
1244	if v.ConnectionName == nil {
1245		invalidParams.Add(smithy.NewErrParamRequired("ConnectionName"))
1246	}
1247	if v.OwnerAccount == nil {
1248		invalidParams.Add(smithy.NewErrParamRequired("OwnerAccount"))
1249	}
1250	if v.InterconnectId == nil {
1251		invalidParams.Add(smithy.NewErrParamRequired("InterconnectId"))
1252	}
1253	if invalidParams.Len() > 0 {
1254		return invalidParams
1255	} else {
1256		return nil
1257	}
1258}
1259
1260func validateOpAllocateHostedConnectionInput(v *AllocateHostedConnectionInput) error {
1261	if v == nil {
1262		return nil
1263	}
1264	invalidParams := smithy.InvalidParamsError{Context: "AllocateHostedConnectionInput"}
1265	if v.ConnectionId == nil {
1266		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1267	}
1268	if v.OwnerAccount == nil {
1269		invalidParams.Add(smithy.NewErrParamRequired("OwnerAccount"))
1270	}
1271	if v.Bandwidth == nil {
1272		invalidParams.Add(smithy.NewErrParamRequired("Bandwidth"))
1273	}
1274	if v.ConnectionName == nil {
1275		invalidParams.Add(smithy.NewErrParamRequired("ConnectionName"))
1276	}
1277	if v.Tags != nil {
1278		if err := validateTagList(v.Tags); err != nil {
1279			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1280		}
1281	}
1282	if invalidParams.Len() > 0 {
1283		return invalidParams
1284	} else {
1285		return nil
1286	}
1287}
1288
1289func validateOpAllocatePrivateVirtualInterfaceInput(v *AllocatePrivateVirtualInterfaceInput) error {
1290	if v == nil {
1291		return nil
1292	}
1293	invalidParams := smithy.InvalidParamsError{Context: "AllocatePrivateVirtualInterfaceInput"}
1294	if v.ConnectionId == nil {
1295		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1296	}
1297	if v.OwnerAccount == nil {
1298		invalidParams.Add(smithy.NewErrParamRequired("OwnerAccount"))
1299	}
1300	if v.NewPrivateVirtualInterfaceAllocation == nil {
1301		invalidParams.Add(smithy.NewErrParamRequired("NewPrivateVirtualInterfaceAllocation"))
1302	} else if v.NewPrivateVirtualInterfaceAllocation != nil {
1303		if err := validateNewPrivateVirtualInterfaceAllocation(v.NewPrivateVirtualInterfaceAllocation); err != nil {
1304			invalidParams.AddNested("NewPrivateVirtualInterfaceAllocation", err.(smithy.InvalidParamsError))
1305		}
1306	}
1307	if invalidParams.Len() > 0 {
1308		return invalidParams
1309	} else {
1310		return nil
1311	}
1312}
1313
1314func validateOpAllocatePublicVirtualInterfaceInput(v *AllocatePublicVirtualInterfaceInput) error {
1315	if v == nil {
1316		return nil
1317	}
1318	invalidParams := smithy.InvalidParamsError{Context: "AllocatePublicVirtualInterfaceInput"}
1319	if v.ConnectionId == nil {
1320		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1321	}
1322	if v.OwnerAccount == nil {
1323		invalidParams.Add(smithy.NewErrParamRequired("OwnerAccount"))
1324	}
1325	if v.NewPublicVirtualInterfaceAllocation == nil {
1326		invalidParams.Add(smithy.NewErrParamRequired("NewPublicVirtualInterfaceAllocation"))
1327	} else if v.NewPublicVirtualInterfaceAllocation != nil {
1328		if err := validateNewPublicVirtualInterfaceAllocation(v.NewPublicVirtualInterfaceAllocation); err != nil {
1329			invalidParams.AddNested("NewPublicVirtualInterfaceAllocation", err.(smithy.InvalidParamsError))
1330		}
1331	}
1332	if invalidParams.Len() > 0 {
1333		return invalidParams
1334	} else {
1335		return nil
1336	}
1337}
1338
1339func validateOpAllocateTransitVirtualInterfaceInput(v *AllocateTransitVirtualInterfaceInput) error {
1340	if v == nil {
1341		return nil
1342	}
1343	invalidParams := smithy.InvalidParamsError{Context: "AllocateTransitVirtualInterfaceInput"}
1344	if v.ConnectionId == nil {
1345		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1346	}
1347	if v.OwnerAccount == nil {
1348		invalidParams.Add(smithy.NewErrParamRequired("OwnerAccount"))
1349	}
1350	if v.NewTransitVirtualInterfaceAllocation == nil {
1351		invalidParams.Add(smithy.NewErrParamRequired("NewTransitVirtualInterfaceAllocation"))
1352	} else if v.NewTransitVirtualInterfaceAllocation != nil {
1353		if err := validateNewTransitVirtualInterfaceAllocation(v.NewTransitVirtualInterfaceAllocation); err != nil {
1354			invalidParams.AddNested("NewTransitVirtualInterfaceAllocation", err.(smithy.InvalidParamsError))
1355		}
1356	}
1357	if invalidParams.Len() > 0 {
1358		return invalidParams
1359	} else {
1360		return nil
1361	}
1362}
1363
1364func validateOpAssociateConnectionWithLagInput(v *AssociateConnectionWithLagInput) error {
1365	if v == nil {
1366		return nil
1367	}
1368	invalidParams := smithy.InvalidParamsError{Context: "AssociateConnectionWithLagInput"}
1369	if v.ConnectionId == nil {
1370		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1371	}
1372	if v.LagId == nil {
1373		invalidParams.Add(smithy.NewErrParamRequired("LagId"))
1374	}
1375	if invalidParams.Len() > 0 {
1376		return invalidParams
1377	} else {
1378		return nil
1379	}
1380}
1381
1382func validateOpAssociateHostedConnectionInput(v *AssociateHostedConnectionInput) error {
1383	if v == nil {
1384		return nil
1385	}
1386	invalidParams := smithy.InvalidParamsError{Context: "AssociateHostedConnectionInput"}
1387	if v.ConnectionId == nil {
1388		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1389	}
1390	if v.ParentConnectionId == nil {
1391		invalidParams.Add(smithy.NewErrParamRequired("ParentConnectionId"))
1392	}
1393	if invalidParams.Len() > 0 {
1394		return invalidParams
1395	} else {
1396		return nil
1397	}
1398}
1399
1400func validateOpAssociateMacSecKeyInput(v *AssociateMacSecKeyInput) error {
1401	if v == nil {
1402		return nil
1403	}
1404	invalidParams := smithy.InvalidParamsError{Context: "AssociateMacSecKeyInput"}
1405	if v.ConnectionId == nil {
1406		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1407	}
1408	if invalidParams.Len() > 0 {
1409		return invalidParams
1410	} else {
1411		return nil
1412	}
1413}
1414
1415func validateOpAssociateVirtualInterfaceInput(v *AssociateVirtualInterfaceInput) error {
1416	if v == nil {
1417		return nil
1418	}
1419	invalidParams := smithy.InvalidParamsError{Context: "AssociateVirtualInterfaceInput"}
1420	if v.VirtualInterfaceId == nil {
1421		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceId"))
1422	}
1423	if v.ConnectionId == nil {
1424		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1425	}
1426	if invalidParams.Len() > 0 {
1427		return invalidParams
1428	} else {
1429		return nil
1430	}
1431}
1432
1433func validateOpConfirmConnectionInput(v *ConfirmConnectionInput) error {
1434	if v == nil {
1435		return nil
1436	}
1437	invalidParams := smithy.InvalidParamsError{Context: "ConfirmConnectionInput"}
1438	if v.ConnectionId == nil {
1439		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1440	}
1441	if invalidParams.Len() > 0 {
1442		return invalidParams
1443	} else {
1444		return nil
1445	}
1446}
1447
1448func validateOpConfirmPrivateVirtualInterfaceInput(v *ConfirmPrivateVirtualInterfaceInput) error {
1449	if v == nil {
1450		return nil
1451	}
1452	invalidParams := smithy.InvalidParamsError{Context: "ConfirmPrivateVirtualInterfaceInput"}
1453	if v.VirtualInterfaceId == nil {
1454		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceId"))
1455	}
1456	if invalidParams.Len() > 0 {
1457		return invalidParams
1458	} else {
1459		return nil
1460	}
1461}
1462
1463func validateOpConfirmPublicVirtualInterfaceInput(v *ConfirmPublicVirtualInterfaceInput) error {
1464	if v == nil {
1465		return nil
1466	}
1467	invalidParams := smithy.InvalidParamsError{Context: "ConfirmPublicVirtualInterfaceInput"}
1468	if v.VirtualInterfaceId == nil {
1469		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceId"))
1470	}
1471	if invalidParams.Len() > 0 {
1472		return invalidParams
1473	} else {
1474		return nil
1475	}
1476}
1477
1478func validateOpConfirmTransitVirtualInterfaceInput(v *ConfirmTransitVirtualInterfaceInput) error {
1479	if v == nil {
1480		return nil
1481	}
1482	invalidParams := smithy.InvalidParamsError{Context: "ConfirmTransitVirtualInterfaceInput"}
1483	if v.VirtualInterfaceId == nil {
1484		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceId"))
1485	}
1486	if v.DirectConnectGatewayId == nil {
1487		invalidParams.Add(smithy.NewErrParamRequired("DirectConnectGatewayId"))
1488	}
1489	if invalidParams.Len() > 0 {
1490		return invalidParams
1491	} else {
1492		return nil
1493	}
1494}
1495
1496func validateOpCreateConnectionInput(v *CreateConnectionInput) error {
1497	if v == nil {
1498		return nil
1499	}
1500	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionInput"}
1501	if v.Location == nil {
1502		invalidParams.Add(smithy.NewErrParamRequired("Location"))
1503	}
1504	if v.Bandwidth == nil {
1505		invalidParams.Add(smithy.NewErrParamRequired("Bandwidth"))
1506	}
1507	if v.ConnectionName == nil {
1508		invalidParams.Add(smithy.NewErrParamRequired("ConnectionName"))
1509	}
1510	if v.Tags != nil {
1511		if err := validateTagList(v.Tags); err != nil {
1512			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1513		}
1514	}
1515	if invalidParams.Len() > 0 {
1516		return invalidParams
1517	} else {
1518		return nil
1519	}
1520}
1521
1522func validateOpCreateDirectConnectGatewayAssociationInput(v *CreateDirectConnectGatewayAssociationInput) error {
1523	if v == nil {
1524		return nil
1525	}
1526	invalidParams := smithy.InvalidParamsError{Context: "CreateDirectConnectGatewayAssociationInput"}
1527	if v.DirectConnectGatewayId == nil {
1528		invalidParams.Add(smithy.NewErrParamRequired("DirectConnectGatewayId"))
1529	}
1530	if invalidParams.Len() > 0 {
1531		return invalidParams
1532	} else {
1533		return nil
1534	}
1535}
1536
1537func validateOpCreateDirectConnectGatewayAssociationProposalInput(v *CreateDirectConnectGatewayAssociationProposalInput) error {
1538	if v == nil {
1539		return nil
1540	}
1541	invalidParams := smithy.InvalidParamsError{Context: "CreateDirectConnectGatewayAssociationProposalInput"}
1542	if v.DirectConnectGatewayId == nil {
1543		invalidParams.Add(smithy.NewErrParamRequired("DirectConnectGatewayId"))
1544	}
1545	if v.DirectConnectGatewayOwnerAccount == nil {
1546		invalidParams.Add(smithy.NewErrParamRequired("DirectConnectGatewayOwnerAccount"))
1547	}
1548	if v.GatewayId == nil {
1549		invalidParams.Add(smithy.NewErrParamRequired("GatewayId"))
1550	}
1551	if invalidParams.Len() > 0 {
1552		return invalidParams
1553	} else {
1554		return nil
1555	}
1556}
1557
1558func validateOpCreateDirectConnectGatewayInput(v *CreateDirectConnectGatewayInput) error {
1559	if v == nil {
1560		return nil
1561	}
1562	invalidParams := smithy.InvalidParamsError{Context: "CreateDirectConnectGatewayInput"}
1563	if v.DirectConnectGatewayName == nil {
1564		invalidParams.Add(smithy.NewErrParamRequired("DirectConnectGatewayName"))
1565	}
1566	if invalidParams.Len() > 0 {
1567		return invalidParams
1568	} else {
1569		return nil
1570	}
1571}
1572
1573func validateOpCreateInterconnectInput(v *CreateInterconnectInput) error {
1574	if v == nil {
1575		return nil
1576	}
1577	invalidParams := smithy.InvalidParamsError{Context: "CreateInterconnectInput"}
1578	if v.InterconnectName == nil {
1579		invalidParams.Add(smithy.NewErrParamRequired("InterconnectName"))
1580	}
1581	if v.Bandwidth == nil {
1582		invalidParams.Add(smithy.NewErrParamRequired("Bandwidth"))
1583	}
1584	if v.Location == nil {
1585		invalidParams.Add(smithy.NewErrParamRequired("Location"))
1586	}
1587	if v.Tags != nil {
1588		if err := validateTagList(v.Tags); err != nil {
1589			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1590		}
1591	}
1592	if invalidParams.Len() > 0 {
1593		return invalidParams
1594	} else {
1595		return nil
1596	}
1597}
1598
1599func validateOpCreateLagInput(v *CreateLagInput) error {
1600	if v == nil {
1601		return nil
1602	}
1603	invalidParams := smithy.InvalidParamsError{Context: "CreateLagInput"}
1604	if v.Location == nil {
1605		invalidParams.Add(smithy.NewErrParamRequired("Location"))
1606	}
1607	if v.ConnectionsBandwidth == nil {
1608		invalidParams.Add(smithy.NewErrParamRequired("ConnectionsBandwidth"))
1609	}
1610	if v.LagName == nil {
1611		invalidParams.Add(smithy.NewErrParamRequired("LagName"))
1612	}
1613	if v.Tags != nil {
1614		if err := validateTagList(v.Tags); err != nil {
1615			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1616		}
1617	}
1618	if v.ChildConnectionTags != nil {
1619		if err := validateTagList(v.ChildConnectionTags); err != nil {
1620			invalidParams.AddNested("ChildConnectionTags", err.(smithy.InvalidParamsError))
1621		}
1622	}
1623	if invalidParams.Len() > 0 {
1624		return invalidParams
1625	} else {
1626		return nil
1627	}
1628}
1629
1630func validateOpCreatePrivateVirtualInterfaceInput(v *CreatePrivateVirtualInterfaceInput) error {
1631	if v == nil {
1632		return nil
1633	}
1634	invalidParams := smithy.InvalidParamsError{Context: "CreatePrivateVirtualInterfaceInput"}
1635	if v.ConnectionId == nil {
1636		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1637	}
1638	if v.NewPrivateVirtualInterface == nil {
1639		invalidParams.Add(smithy.NewErrParamRequired("NewPrivateVirtualInterface"))
1640	} else if v.NewPrivateVirtualInterface != nil {
1641		if err := validateNewPrivateVirtualInterface(v.NewPrivateVirtualInterface); err != nil {
1642			invalidParams.AddNested("NewPrivateVirtualInterface", err.(smithy.InvalidParamsError))
1643		}
1644	}
1645	if invalidParams.Len() > 0 {
1646		return invalidParams
1647	} else {
1648		return nil
1649	}
1650}
1651
1652func validateOpCreatePublicVirtualInterfaceInput(v *CreatePublicVirtualInterfaceInput) error {
1653	if v == nil {
1654		return nil
1655	}
1656	invalidParams := smithy.InvalidParamsError{Context: "CreatePublicVirtualInterfaceInput"}
1657	if v.ConnectionId == nil {
1658		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1659	}
1660	if v.NewPublicVirtualInterface == nil {
1661		invalidParams.Add(smithy.NewErrParamRequired("NewPublicVirtualInterface"))
1662	} else if v.NewPublicVirtualInterface != nil {
1663		if err := validateNewPublicVirtualInterface(v.NewPublicVirtualInterface); err != nil {
1664			invalidParams.AddNested("NewPublicVirtualInterface", err.(smithy.InvalidParamsError))
1665		}
1666	}
1667	if invalidParams.Len() > 0 {
1668		return invalidParams
1669	} else {
1670		return nil
1671	}
1672}
1673
1674func validateOpCreateTransitVirtualInterfaceInput(v *CreateTransitVirtualInterfaceInput) error {
1675	if v == nil {
1676		return nil
1677	}
1678	invalidParams := smithy.InvalidParamsError{Context: "CreateTransitVirtualInterfaceInput"}
1679	if v.ConnectionId == nil {
1680		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1681	}
1682	if v.NewTransitVirtualInterface == nil {
1683		invalidParams.Add(smithy.NewErrParamRequired("NewTransitVirtualInterface"))
1684	} else if v.NewTransitVirtualInterface != nil {
1685		if err := validateNewTransitVirtualInterface(v.NewTransitVirtualInterface); err != nil {
1686			invalidParams.AddNested("NewTransitVirtualInterface", err.(smithy.InvalidParamsError))
1687		}
1688	}
1689	if invalidParams.Len() > 0 {
1690		return invalidParams
1691	} else {
1692		return nil
1693	}
1694}
1695
1696func validateOpDeleteConnectionInput(v *DeleteConnectionInput) error {
1697	if v == nil {
1698		return nil
1699	}
1700	invalidParams := smithy.InvalidParamsError{Context: "DeleteConnectionInput"}
1701	if v.ConnectionId == nil {
1702		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1703	}
1704	if invalidParams.Len() > 0 {
1705		return invalidParams
1706	} else {
1707		return nil
1708	}
1709}
1710
1711func validateOpDeleteDirectConnectGatewayAssociationProposalInput(v *DeleteDirectConnectGatewayAssociationProposalInput) error {
1712	if v == nil {
1713		return nil
1714	}
1715	invalidParams := smithy.InvalidParamsError{Context: "DeleteDirectConnectGatewayAssociationProposalInput"}
1716	if v.ProposalId == nil {
1717		invalidParams.Add(smithy.NewErrParamRequired("ProposalId"))
1718	}
1719	if invalidParams.Len() > 0 {
1720		return invalidParams
1721	} else {
1722		return nil
1723	}
1724}
1725
1726func validateOpDeleteDirectConnectGatewayInput(v *DeleteDirectConnectGatewayInput) error {
1727	if v == nil {
1728		return nil
1729	}
1730	invalidParams := smithy.InvalidParamsError{Context: "DeleteDirectConnectGatewayInput"}
1731	if v.DirectConnectGatewayId == nil {
1732		invalidParams.Add(smithy.NewErrParamRequired("DirectConnectGatewayId"))
1733	}
1734	if invalidParams.Len() > 0 {
1735		return invalidParams
1736	} else {
1737		return nil
1738	}
1739}
1740
1741func validateOpDeleteInterconnectInput(v *DeleteInterconnectInput) error {
1742	if v == nil {
1743		return nil
1744	}
1745	invalidParams := smithy.InvalidParamsError{Context: "DeleteInterconnectInput"}
1746	if v.InterconnectId == nil {
1747		invalidParams.Add(smithy.NewErrParamRequired("InterconnectId"))
1748	}
1749	if invalidParams.Len() > 0 {
1750		return invalidParams
1751	} else {
1752		return nil
1753	}
1754}
1755
1756func validateOpDeleteLagInput(v *DeleteLagInput) error {
1757	if v == nil {
1758		return nil
1759	}
1760	invalidParams := smithy.InvalidParamsError{Context: "DeleteLagInput"}
1761	if v.LagId == nil {
1762		invalidParams.Add(smithy.NewErrParamRequired("LagId"))
1763	}
1764	if invalidParams.Len() > 0 {
1765		return invalidParams
1766	} else {
1767		return nil
1768	}
1769}
1770
1771func validateOpDeleteVirtualInterfaceInput(v *DeleteVirtualInterfaceInput) error {
1772	if v == nil {
1773		return nil
1774	}
1775	invalidParams := smithy.InvalidParamsError{Context: "DeleteVirtualInterfaceInput"}
1776	if v.VirtualInterfaceId == nil {
1777		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceId"))
1778	}
1779	if invalidParams.Len() > 0 {
1780		return invalidParams
1781	} else {
1782		return nil
1783	}
1784}
1785
1786func validateOpDescribeConnectionLoaInput(v *DescribeConnectionLoaInput) error {
1787	if v == nil {
1788		return nil
1789	}
1790	invalidParams := smithy.InvalidParamsError{Context: "DescribeConnectionLoaInput"}
1791	if v.ConnectionId == nil {
1792		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1793	}
1794	if invalidParams.Len() > 0 {
1795		return invalidParams
1796	} else {
1797		return nil
1798	}
1799}
1800
1801func validateOpDescribeConnectionsOnInterconnectInput(v *DescribeConnectionsOnInterconnectInput) error {
1802	if v == nil {
1803		return nil
1804	}
1805	invalidParams := smithy.InvalidParamsError{Context: "DescribeConnectionsOnInterconnectInput"}
1806	if v.InterconnectId == nil {
1807		invalidParams.Add(smithy.NewErrParamRequired("InterconnectId"))
1808	}
1809	if invalidParams.Len() > 0 {
1810		return invalidParams
1811	} else {
1812		return nil
1813	}
1814}
1815
1816func validateOpDescribeHostedConnectionsInput(v *DescribeHostedConnectionsInput) error {
1817	if v == nil {
1818		return nil
1819	}
1820	invalidParams := smithy.InvalidParamsError{Context: "DescribeHostedConnectionsInput"}
1821	if v.ConnectionId == nil {
1822		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1823	}
1824	if invalidParams.Len() > 0 {
1825		return invalidParams
1826	} else {
1827		return nil
1828	}
1829}
1830
1831func validateOpDescribeInterconnectLoaInput(v *DescribeInterconnectLoaInput) error {
1832	if v == nil {
1833		return nil
1834	}
1835	invalidParams := smithy.InvalidParamsError{Context: "DescribeInterconnectLoaInput"}
1836	if v.InterconnectId == nil {
1837		invalidParams.Add(smithy.NewErrParamRequired("InterconnectId"))
1838	}
1839	if invalidParams.Len() > 0 {
1840		return invalidParams
1841	} else {
1842		return nil
1843	}
1844}
1845
1846func validateOpDescribeLoaInput(v *DescribeLoaInput) error {
1847	if v == nil {
1848		return nil
1849	}
1850	invalidParams := smithy.InvalidParamsError{Context: "DescribeLoaInput"}
1851	if v.ConnectionId == nil {
1852		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1853	}
1854	if invalidParams.Len() > 0 {
1855		return invalidParams
1856	} else {
1857		return nil
1858	}
1859}
1860
1861func validateOpDescribeTagsInput(v *DescribeTagsInput) error {
1862	if v == nil {
1863		return nil
1864	}
1865	invalidParams := smithy.InvalidParamsError{Context: "DescribeTagsInput"}
1866	if v.ResourceArns == nil {
1867		invalidParams.Add(smithy.NewErrParamRequired("ResourceArns"))
1868	}
1869	if invalidParams.Len() > 0 {
1870		return invalidParams
1871	} else {
1872		return nil
1873	}
1874}
1875
1876func validateOpDisassociateConnectionFromLagInput(v *DisassociateConnectionFromLagInput) error {
1877	if v == nil {
1878		return nil
1879	}
1880	invalidParams := smithy.InvalidParamsError{Context: "DisassociateConnectionFromLagInput"}
1881	if v.ConnectionId == nil {
1882		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1883	}
1884	if v.LagId == nil {
1885		invalidParams.Add(smithy.NewErrParamRequired("LagId"))
1886	}
1887	if invalidParams.Len() > 0 {
1888		return invalidParams
1889	} else {
1890		return nil
1891	}
1892}
1893
1894func validateOpDisassociateMacSecKeyInput(v *DisassociateMacSecKeyInput) error {
1895	if v == nil {
1896		return nil
1897	}
1898	invalidParams := smithy.InvalidParamsError{Context: "DisassociateMacSecKeyInput"}
1899	if v.ConnectionId == nil {
1900		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1901	}
1902	if v.SecretARN == nil {
1903		invalidParams.Add(smithy.NewErrParamRequired("SecretARN"))
1904	}
1905	if invalidParams.Len() > 0 {
1906		return invalidParams
1907	} else {
1908		return nil
1909	}
1910}
1911
1912func validateOpStartBgpFailoverTestInput(v *StartBgpFailoverTestInput) error {
1913	if v == nil {
1914		return nil
1915	}
1916	invalidParams := smithy.InvalidParamsError{Context: "StartBgpFailoverTestInput"}
1917	if v.VirtualInterfaceId == nil {
1918		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceId"))
1919	}
1920	if invalidParams.Len() > 0 {
1921		return invalidParams
1922	} else {
1923		return nil
1924	}
1925}
1926
1927func validateOpStopBgpFailoverTestInput(v *StopBgpFailoverTestInput) error {
1928	if v == nil {
1929		return nil
1930	}
1931	invalidParams := smithy.InvalidParamsError{Context: "StopBgpFailoverTestInput"}
1932	if v.VirtualInterfaceId == nil {
1933		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceId"))
1934	}
1935	if invalidParams.Len() > 0 {
1936		return invalidParams
1937	} else {
1938		return nil
1939	}
1940}
1941
1942func validateOpTagResourceInput(v *TagResourceInput) error {
1943	if v == nil {
1944		return nil
1945	}
1946	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
1947	if v.ResourceArn == nil {
1948		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1949	}
1950	if v.Tags == nil {
1951		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1952	} else if v.Tags != nil {
1953		if err := validateTagList(v.Tags); err != nil {
1954			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1955		}
1956	}
1957	if invalidParams.Len() > 0 {
1958		return invalidParams
1959	} else {
1960		return nil
1961	}
1962}
1963
1964func validateOpUntagResourceInput(v *UntagResourceInput) error {
1965	if v == nil {
1966		return nil
1967	}
1968	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
1969	if v.ResourceArn == nil {
1970		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
1971	}
1972	if v.TagKeys == nil {
1973		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1974	}
1975	if invalidParams.Len() > 0 {
1976		return invalidParams
1977	} else {
1978		return nil
1979	}
1980}
1981
1982func validateOpUpdateConnectionInput(v *UpdateConnectionInput) error {
1983	if v == nil {
1984		return nil
1985	}
1986	invalidParams := smithy.InvalidParamsError{Context: "UpdateConnectionInput"}
1987	if v.ConnectionId == nil {
1988		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
1989	}
1990	if invalidParams.Len() > 0 {
1991		return invalidParams
1992	} else {
1993		return nil
1994	}
1995}
1996
1997func validateOpUpdateLagInput(v *UpdateLagInput) error {
1998	if v == nil {
1999		return nil
2000	}
2001	invalidParams := smithy.InvalidParamsError{Context: "UpdateLagInput"}
2002	if v.LagId == nil {
2003		invalidParams.Add(smithy.NewErrParamRequired("LagId"))
2004	}
2005	if invalidParams.Len() > 0 {
2006		return invalidParams
2007	} else {
2008		return nil
2009	}
2010}
2011
2012func validateOpUpdateVirtualInterfaceAttributesInput(v *UpdateVirtualInterfaceAttributesInput) error {
2013	if v == nil {
2014		return nil
2015	}
2016	invalidParams := smithy.InvalidParamsError{Context: "UpdateVirtualInterfaceAttributesInput"}
2017	if v.VirtualInterfaceId == nil {
2018		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceId"))
2019	}
2020	if invalidParams.Len() > 0 {
2021		return invalidParams
2022	} else {
2023		return nil
2024	}
2025}
2026