1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package eventbridge
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/eventbridge/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpActivateEventSource struct {
14}
15
16func (*validateOpActivateEventSource) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpActivateEventSource) 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.(*ActivateEventSourceInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpActivateEventSourceInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpCancelReplay struct {
34}
35
36func (*validateOpCancelReplay) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpCancelReplay) 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.(*CancelReplayInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpCancelReplayInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpCreateApiDestination struct {
54}
55
56func (*validateOpCreateApiDestination) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateApiDestination) 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.(*CreateApiDestinationInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateApiDestinationInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateArchive struct {
74}
75
76func (*validateOpCreateArchive) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateArchive) 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.(*CreateArchiveInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateArchiveInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateConnection struct {
94}
95
96func (*validateOpCreateConnection) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateConnection) 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.(*CreateConnectionInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateConnectionInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateEventBus struct {
114}
115
116func (*validateOpCreateEventBus) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateEventBus) 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.(*CreateEventBusInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateEventBusInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpCreatePartnerEventSource struct {
134}
135
136func (*validateOpCreatePartnerEventSource) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpCreatePartnerEventSource) 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.(*CreatePartnerEventSourceInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpCreatePartnerEventSourceInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDeactivateEventSource struct {
154}
155
156func (*validateOpDeactivateEventSource) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDeactivateEventSource) 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.(*DeactivateEventSourceInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDeactivateEventSourceInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDeauthorizeConnection struct {
174}
175
176func (*validateOpDeauthorizeConnection) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDeauthorizeConnection) 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.(*DeauthorizeConnectionInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDeauthorizeConnectionInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDeleteApiDestination struct {
194}
195
196func (*validateOpDeleteApiDestination) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDeleteApiDestination) 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.(*DeleteApiDestinationInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDeleteApiDestinationInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpDeleteArchive struct {
214}
215
216func (*validateOpDeleteArchive) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpDeleteArchive) 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.(*DeleteArchiveInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpDeleteArchiveInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDeleteConnection struct {
234}
235
236func (*validateOpDeleteConnection) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDeleteConnection) 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.(*DeleteConnectionInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDeleteConnectionInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDeleteEventBus struct {
254}
255
256func (*validateOpDeleteEventBus) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDeleteEventBus) 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.(*DeleteEventBusInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDeleteEventBusInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDeletePartnerEventSource struct {
274}
275
276func (*validateOpDeletePartnerEventSource) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDeletePartnerEventSource) 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.(*DeletePartnerEventSourceInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDeletePartnerEventSourceInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDeleteRule struct {
294}
295
296func (*validateOpDeleteRule) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDeleteRule) 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.(*DeleteRuleInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDeleteRuleInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDescribeApiDestination struct {
314}
315
316func (*validateOpDescribeApiDestination) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDescribeApiDestination) 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.(*DescribeApiDestinationInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDescribeApiDestinationInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDescribeArchive struct {
334}
335
336func (*validateOpDescribeArchive) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDescribeArchive) 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.(*DescribeArchiveInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDescribeArchiveInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDescribeConnection struct {
354}
355
356func (*validateOpDescribeConnection) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDescribeConnection) 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.(*DescribeConnectionInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDescribeConnectionInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDescribeEventSource struct {
374}
375
376func (*validateOpDescribeEventSource) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDescribeEventSource) 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.(*DescribeEventSourceInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDescribeEventSourceInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDescribePartnerEventSource struct {
394}
395
396func (*validateOpDescribePartnerEventSource) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDescribePartnerEventSource) 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.(*DescribePartnerEventSourceInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDescribePartnerEventSourceInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDescribeReplay struct {
414}
415
416func (*validateOpDescribeReplay) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDescribeReplay) 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.(*DescribeReplayInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDescribeReplayInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpDescribeRule struct {
434}
435
436func (*validateOpDescribeRule) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpDescribeRule) 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.(*DescribeRuleInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpDescribeRuleInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpDisableRule struct {
454}
455
456func (*validateOpDisableRule) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpDisableRule) 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.(*DisableRuleInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpDisableRuleInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpEnableRule struct {
474}
475
476func (*validateOpEnableRule) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpEnableRule) 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.(*EnableRuleInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpEnableRuleInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpListPartnerEventSourceAccounts struct {
494}
495
496func (*validateOpListPartnerEventSourceAccounts) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpListPartnerEventSourceAccounts) 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.(*ListPartnerEventSourceAccountsInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpListPartnerEventSourceAccountsInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpListPartnerEventSources struct {
514}
515
516func (*validateOpListPartnerEventSources) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpListPartnerEventSources) 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.(*ListPartnerEventSourcesInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpListPartnerEventSourcesInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpListRuleNamesByTarget struct {
534}
535
536func (*validateOpListRuleNamesByTarget) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpListRuleNamesByTarget) 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.(*ListRuleNamesByTargetInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpListRuleNamesByTargetInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpListTagsForResource struct {
554}
555
556func (*validateOpListTagsForResource) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpListTagsForResourceInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpListTargetsByRule struct {
574}
575
576func (*validateOpListTargetsByRule) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpListTargetsByRule) 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.(*ListTargetsByRuleInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpListTargetsByRuleInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpPutEvents struct {
594}
595
596func (*validateOpPutEvents) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpPutEvents) 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.(*PutEventsInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpPutEventsInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpPutPartnerEvents struct {
614}
615
616func (*validateOpPutPartnerEvents) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpPutPartnerEvents) 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.(*PutPartnerEventsInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpPutPartnerEventsInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpPutPermission struct {
634}
635
636func (*validateOpPutPermission) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpPutPermission) 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.(*PutPermissionInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpPutPermissionInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpPutRule struct {
654}
655
656func (*validateOpPutRule) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpPutRule) 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.(*PutRuleInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpPutRuleInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpPutTargets struct {
674}
675
676func (*validateOpPutTargets) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpPutTargets) 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.(*PutTargetsInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpPutTargetsInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpRemoveTargets struct {
694}
695
696func (*validateOpRemoveTargets) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpRemoveTargets) 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.(*RemoveTargetsInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpRemoveTargetsInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpStartReplay struct {
714}
715
716func (*validateOpStartReplay) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpStartReplay) 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.(*StartReplayInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpStartReplayInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpTagResource struct {
734}
735
736func (*validateOpTagResource) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpTagResource) 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.(*TagResourceInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpTagResourceInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpTestEventPattern struct {
754}
755
756func (*validateOpTestEventPattern) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpTestEventPattern) 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.(*TestEventPatternInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpTestEventPatternInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpUntagResource struct {
774}
775
776func (*validateOpUntagResource) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpUntagResource) 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.(*UntagResourceInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpUntagResourceInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpUpdateApiDestination struct {
794}
795
796func (*validateOpUpdateApiDestination) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpUpdateApiDestination) 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.(*UpdateApiDestinationInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpUpdateApiDestinationInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpUpdateArchive struct {
814}
815
816func (*validateOpUpdateArchive) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpUpdateArchive) 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.(*UpdateArchiveInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpUpdateArchiveInput(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
853func addOpActivateEventSourceValidationMiddleware(stack *middleware.Stack) error {
854	return stack.Initialize.Add(&validateOpActivateEventSource{}, middleware.After)
855}
856
857func addOpCancelReplayValidationMiddleware(stack *middleware.Stack) error {
858	return stack.Initialize.Add(&validateOpCancelReplay{}, middleware.After)
859}
860
861func addOpCreateApiDestinationValidationMiddleware(stack *middleware.Stack) error {
862	return stack.Initialize.Add(&validateOpCreateApiDestination{}, middleware.After)
863}
864
865func addOpCreateArchiveValidationMiddleware(stack *middleware.Stack) error {
866	return stack.Initialize.Add(&validateOpCreateArchive{}, middleware.After)
867}
868
869func addOpCreateConnectionValidationMiddleware(stack *middleware.Stack) error {
870	return stack.Initialize.Add(&validateOpCreateConnection{}, middleware.After)
871}
872
873func addOpCreateEventBusValidationMiddleware(stack *middleware.Stack) error {
874	return stack.Initialize.Add(&validateOpCreateEventBus{}, middleware.After)
875}
876
877func addOpCreatePartnerEventSourceValidationMiddleware(stack *middleware.Stack) error {
878	return stack.Initialize.Add(&validateOpCreatePartnerEventSource{}, middleware.After)
879}
880
881func addOpDeactivateEventSourceValidationMiddleware(stack *middleware.Stack) error {
882	return stack.Initialize.Add(&validateOpDeactivateEventSource{}, middleware.After)
883}
884
885func addOpDeauthorizeConnectionValidationMiddleware(stack *middleware.Stack) error {
886	return stack.Initialize.Add(&validateOpDeauthorizeConnection{}, middleware.After)
887}
888
889func addOpDeleteApiDestinationValidationMiddleware(stack *middleware.Stack) error {
890	return stack.Initialize.Add(&validateOpDeleteApiDestination{}, middleware.After)
891}
892
893func addOpDeleteArchiveValidationMiddleware(stack *middleware.Stack) error {
894	return stack.Initialize.Add(&validateOpDeleteArchive{}, middleware.After)
895}
896
897func addOpDeleteConnectionValidationMiddleware(stack *middleware.Stack) error {
898	return stack.Initialize.Add(&validateOpDeleteConnection{}, middleware.After)
899}
900
901func addOpDeleteEventBusValidationMiddleware(stack *middleware.Stack) error {
902	return stack.Initialize.Add(&validateOpDeleteEventBus{}, middleware.After)
903}
904
905func addOpDeletePartnerEventSourceValidationMiddleware(stack *middleware.Stack) error {
906	return stack.Initialize.Add(&validateOpDeletePartnerEventSource{}, middleware.After)
907}
908
909func addOpDeleteRuleValidationMiddleware(stack *middleware.Stack) error {
910	return stack.Initialize.Add(&validateOpDeleteRule{}, middleware.After)
911}
912
913func addOpDescribeApiDestinationValidationMiddleware(stack *middleware.Stack) error {
914	return stack.Initialize.Add(&validateOpDescribeApiDestination{}, middleware.After)
915}
916
917func addOpDescribeArchiveValidationMiddleware(stack *middleware.Stack) error {
918	return stack.Initialize.Add(&validateOpDescribeArchive{}, middleware.After)
919}
920
921func addOpDescribeConnectionValidationMiddleware(stack *middleware.Stack) error {
922	return stack.Initialize.Add(&validateOpDescribeConnection{}, middleware.After)
923}
924
925func addOpDescribeEventSourceValidationMiddleware(stack *middleware.Stack) error {
926	return stack.Initialize.Add(&validateOpDescribeEventSource{}, middleware.After)
927}
928
929func addOpDescribePartnerEventSourceValidationMiddleware(stack *middleware.Stack) error {
930	return stack.Initialize.Add(&validateOpDescribePartnerEventSource{}, middleware.After)
931}
932
933func addOpDescribeReplayValidationMiddleware(stack *middleware.Stack) error {
934	return stack.Initialize.Add(&validateOpDescribeReplay{}, middleware.After)
935}
936
937func addOpDescribeRuleValidationMiddleware(stack *middleware.Stack) error {
938	return stack.Initialize.Add(&validateOpDescribeRule{}, middleware.After)
939}
940
941func addOpDisableRuleValidationMiddleware(stack *middleware.Stack) error {
942	return stack.Initialize.Add(&validateOpDisableRule{}, middleware.After)
943}
944
945func addOpEnableRuleValidationMiddleware(stack *middleware.Stack) error {
946	return stack.Initialize.Add(&validateOpEnableRule{}, middleware.After)
947}
948
949func addOpListPartnerEventSourceAccountsValidationMiddleware(stack *middleware.Stack) error {
950	return stack.Initialize.Add(&validateOpListPartnerEventSourceAccounts{}, middleware.After)
951}
952
953func addOpListPartnerEventSourcesValidationMiddleware(stack *middleware.Stack) error {
954	return stack.Initialize.Add(&validateOpListPartnerEventSources{}, middleware.After)
955}
956
957func addOpListRuleNamesByTargetValidationMiddleware(stack *middleware.Stack) error {
958	return stack.Initialize.Add(&validateOpListRuleNamesByTarget{}, middleware.After)
959}
960
961func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
962	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
963}
964
965func addOpListTargetsByRuleValidationMiddleware(stack *middleware.Stack) error {
966	return stack.Initialize.Add(&validateOpListTargetsByRule{}, middleware.After)
967}
968
969func addOpPutEventsValidationMiddleware(stack *middleware.Stack) error {
970	return stack.Initialize.Add(&validateOpPutEvents{}, middleware.After)
971}
972
973func addOpPutPartnerEventsValidationMiddleware(stack *middleware.Stack) error {
974	return stack.Initialize.Add(&validateOpPutPartnerEvents{}, middleware.After)
975}
976
977func addOpPutPermissionValidationMiddleware(stack *middleware.Stack) error {
978	return stack.Initialize.Add(&validateOpPutPermission{}, middleware.After)
979}
980
981func addOpPutRuleValidationMiddleware(stack *middleware.Stack) error {
982	return stack.Initialize.Add(&validateOpPutRule{}, middleware.After)
983}
984
985func addOpPutTargetsValidationMiddleware(stack *middleware.Stack) error {
986	return stack.Initialize.Add(&validateOpPutTargets{}, middleware.After)
987}
988
989func addOpRemoveTargetsValidationMiddleware(stack *middleware.Stack) error {
990	return stack.Initialize.Add(&validateOpRemoveTargets{}, middleware.After)
991}
992
993func addOpStartReplayValidationMiddleware(stack *middleware.Stack) error {
994	return stack.Initialize.Add(&validateOpStartReplay{}, middleware.After)
995}
996
997func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
998	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
999}
1000
1001func addOpTestEventPatternValidationMiddleware(stack *middleware.Stack) error {
1002	return stack.Initialize.Add(&validateOpTestEventPattern{}, middleware.After)
1003}
1004
1005func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
1006	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
1007}
1008
1009func addOpUpdateApiDestinationValidationMiddleware(stack *middleware.Stack) error {
1010	return stack.Initialize.Add(&validateOpUpdateApiDestination{}, middleware.After)
1011}
1012
1013func addOpUpdateArchiveValidationMiddleware(stack *middleware.Stack) error {
1014	return stack.Initialize.Add(&validateOpUpdateArchive{}, middleware.After)
1015}
1016
1017func addOpUpdateConnectionValidationMiddleware(stack *middleware.Stack) error {
1018	return stack.Initialize.Add(&validateOpUpdateConnection{}, middleware.After)
1019}
1020
1021func validateAwsVpcConfiguration(v *types.AwsVpcConfiguration) error {
1022	if v == nil {
1023		return nil
1024	}
1025	invalidParams := smithy.InvalidParamsError{Context: "AwsVpcConfiguration"}
1026	if v.Subnets == nil {
1027		invalidParams.Add(smithy.NewErrParamRequired("Subnets"))
1028	}
1029	if invalidParams.Len() > 0 {
1030		return invalidParams
1031	} else {
1032		return nil
1033	}
1034}
1035
1036func validateBatchParameters(v *types.BatchParameters) error {
1037	if v == nil {
1038		return nil
1039	}
1040	invalidParams := smithy.InvalidParamsError{Context: "BatchParameters"}
1041	if v.JobDefinition == nil {
1042		invalidParams.Add(smithy.NewErrParamRequired("JobDefinition"))
1043	}
1044	if v.JobName == nil {
1045		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
1046	}
1047	if invalidParams.Len() > 0 {
1048		return invalidParams
1049	} else {
1050		return nil
1051	}
1052}
1053
1054func validateCondition(v *types.Condition) error {
1055	if v == nil {
1056		return nil
1057	}
1058	invalidParams := smithy.InvalidParamsError{Context: "Condition"}
1059	if v.Type == nil {
1060		invalidParams.Add(smithy.NewErrParamRequired("Type"))
1061	}
1062	if v.Key == nil {
1063		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1064	}
1065	if v.Value == nil {
1066		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1067	}
1068	if invalidParams.Len() > 0 {
1069		return invalidParams
1070	} else {
1071		return nil
1072	}
1073}
1074
1075func validateCreateConnectionApiKeyAuthRequestParameters(v *types.CreateConnectionApiKeyAuthRequestParameters) error {
1076	if v == nil {
1077		return nil
1078	}
1079	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionApiKeyAuthRequestParameters"}
1080	if v.ApiKeyName == nil {
1081		invalidParams.Add(smithy.NewErrParamRequired("ApiKeyName"))
1082	}
1083	if v.ApiKeyValue == nil {
1084		invalidParams.Add(smithy.NewErrParamRequired("ApiKeyValue"))
1085	}
1086	if invalidParams.Len() > 0 {
1087		return invalidParams
1088	} else {
1089		return nil
1090	}
1091}
1092
1093func validateCreateConnectionAuthRequestParameters(v *types.CreateConnectionAuthRequestParameters) error {
1094	if v == nil {
1095		return nil
1096	}
1097	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionAuthRequestParameters"}
1098	if v.BasicAuthParameters != nil {
1099		if err := validateCreateConnectionBasicAuthRequestParameters(v.BasicAuthParameters); err != nil {
1100			invalidParams.AddNested("BasicAuthParameters", err.(smithy.InvalidParamsError))
1101		}
1102	}
1103	if v.OAuthParameters != nil {
1104		if err := validateCreateConnectionOAuthRequestParameters(v.OAuthParameters); err != nil {
1105			invalidParams.AddNested("OAuthParameters", err.(smithy.InvalidParamsError))
1106		}
1107	}
1108	if v.ApiKeyAuthParameters != nil {
1109		if err := validateCreateConnectionApiKeyAuthRequestParameters(v.ApiKeyAuthParameters); err != nil {
1110			invalidParams.AddNested("ApiKeyAuthParameters", err.(smithy.InvalidParamsError))
1111		}
1112	}
1113	if invalidParams.Len() > 0 {
1114		return invalidParams
1115	} else {
1116		return nil
1117	}
1118}
1119
1120func validateCreateConnectionBasicAuthRequestParameters(v *types.CreateConnectionBasicAuthRequestParameters) error {
1121	if v == nil {
1122		return nil
1123	}
1124	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionBasicAuthRequestParameters"}
1125	if v.Username == nil {
1126		invalidParams.Add(smithy.NewErrParamRequired("Username"))
1127	}
1128	if v.Password == nil {
1129		invalidParams.Add(smithy.NewErrParamRequired("Password"))
1130	}
1131	if invalidParams.Len() > 0 {
1132		return invalidParams
1133	} else {
1134		return nil
1135	}
1136}
1137
1138func validateCreateConnectionOAuthClientRequestParameters(v *types.CreateConnectionOAuthClientRequestParameters) error {
1139	if v == nil {
1140		return nil
1141	}
1142	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionOAuthClientRequestParameters"}
1143	if v.ClientID == nil {
1144		invalidParams.Add(smithy.NewErrParamRequired("ClientID"))
1145	}
1146	if v.ClientSecret == nil {
1147		invalidParams.Add(smithy.NewErrParamRequired("ClientSecret"))
1148	}
1149	if invalidParams.Len() > 0 {
1150		return invalidParams
1151	} else {
1152		return nil
1153	}
1154}
1155
1156func validateCreateConnectionOAuthRequestParameters(v *types.CreateConnectionOAuthRequestParameters) error {
1157	if v == nil {
1158		return nil
1159	}
1160	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionOAuthRequestParameters"}
1161	if v.ClientParameters == nil {
1162		invalidParams.Add(smithy.NewErrParamRequired("ClientParameters"))
1163	} else if v.ClientParameters != nil {
1164		if err := validateCreateConnectionOAuthClientRequestParameters(v.ClientParameters); err != nil {
1165			invalidParams.AddNested("ClientParameters", err.(smithy.InvalidParamsError))
1166		}
1167	}
1168	if v.AuthorizationEndpoint == nil {
1169		invalidParams.Add(smithy.NewErrParamRequired("AuthorizationEndpoint"))
1170	}
1171	if len(v.HttpMethod) == 0 {
1172		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
1173	}
1174	if invalidParams.Len() > 0 {
1175		return invalidParams
1176	} else {
1177		return nil
1178	}
1179}
1180
1181func validateEcsParameters(v *types.EcsParameters) error {
1182	if v == nil {
1183		return nil
1184	}
1185	invalidParams := smithy.InvalidParamsError{Context: "EcsParameters"}
1186	if v.TaskDefinitionArn == nil {
1187		invalidParams.Add(smithy.NewErrParamRequired("TaskDefinitionArn"))
1188	}
1189	if v.NetworkConfiguration != nil {
1190		if err := validateNetworkConfiguration(v.NetworkConfiguration); err != nil {
1191			invalidParams.AddNested("NetworkConfiguration", err.(smithy.InvalidParamsError))
1192		}
1193	}
1194	if invalidParams.Len() > 0 {
1195		return invalidParams
1196	} else {
1197		return nil
1198	}
1199}
1200
1201func validateInputTransformer(v *types.InputTransformer) error {
1202	if v == nil {
1203		return nil
1204	}
1205	invalidParams := smithy.InvalidParamsError{Context: "InputTransformer"}
1206	if v.InputTemplate == nil {
1207		invalidParams.Add(smithy.NewErrParamRequired("InputTemplate"))
1208	}
1209	if invalidParams.Len() > 0 {
1210		return invalidParams
1211	} else {
1212		return nil
1213	}
1214}
1215
1216func validateKinesisParameters(v *types.KinesisParameters) error {
1217	if v == nil {
1218		return nil
1219	}
1220	invalidParams := smithy.InvalidParamsError{Context: "KinesisParameters"}
1221	if v.PartitionKeyPath == nil {
1222		invalidParams.Add(smithy.NewErrParamRequired("PartitionKeyPath"))
1223	}
1224	if invalidParams.Len() > 0 {
1225		return invalidParams
1226	} else {
1227		return nil
1228	}
1229}
1230
1231func validateNetworkConfiguration(v *types.NetworkConfiguration) error {
1232	if v == nil {
1233		return nil
1234	}
1235	invalidParams := smithy.InvalidParamsError{Context: "NetworkConfiguration"}
1236	if v.AwsvpcConfiguration != nil {
1237		if err := validateAwsVpcConfiguration(v.AwsvpcConfiguration); err != nil {
1238			invalidParams.AddNested("AwsvpcConfiguration", err.(smithy.InvalidParamsError))
1239		}
1240	}
1241	if invalidParams.Len() > 0 {
1242		return invalidParams
1243	} else {
1244		return nil
1245	}
1246}
1247
1248func validateRedshiftDataParameters(v *types.RedshiftDataParameters) error {
1249	if v == nil {
1250		return nil
1251	}
1252	invalidParams := smithy.InvalidParamsError{Context: "RedshiftDataParameters"}
1253	if v.Database == nil {
1254		invalidParams.Add(smithy.NewErrParamRequired("Database"))
1255	}
1256	if v.Sql == nil {
1257		invalidParams.Add(smithy.NewErrParamRequired("Sql"))
1258	}
1259	if invalidParams.Len() > 0 {
1260		return invalidParams
1261	} else {
1262		return nil
1263	}
1264}
1265
1266func validateReplayDestination(v *types.ReplayDestination) error {
1267	if v == nil {
1268		return nil
1269	}
1270	invalidParams := smithy.InvalidParamsError{Context: "ReplayDestination"}
1271	if v.Arn == nil {
1272		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
1273	}
1274	if invalidParams.Len() > 0 {
1275		return invalidParams
1276	} else {
1277		return nil
1278	}
1279}
1280
1281func validateRunCommandParameters(v *types.RunCommandParameters) error {
1282	if v == nil {
1283		return nil
1284	}
1285	invalidParams := smithy.InvalidParamsError{Context: "RunCommandParameters"}
1286	if v.RunCommandTargets == nil {
1287		invalidParams.Add(smithy.NewErrParamRequired("RunCommandTargets"))
1288	} else if v.RunCommandTargets != nil {
1289		if err := validateRunCommandTargets(v.RunCommandTargets); err != nil {
1290			invalidParams.AddNested("RunCommandTargets", err.(smithy.InvalidParamsError))
1291		}
1292	}
1293	if invalidParams.Len() > 0 {
1294		return invalidParams
1295	} else {
1296		return nil
1297	}
1298}
1299
1300func validateRunCommandTarget(v *types.RunCommandTarget) error {
1301	if v == nil {
1302		return nil
1303	}
1304	invalidParams := smithy.InvalidParamsError{Context: "RunCommandTarget"}
1305	if v.Key == nil {
1306		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1307	}
1308	if v.Values == nil {
1309		invalidParams.Add(smithy.NewErrParamRequired("Values"))
1310	}
1311	if invalidParams.Len() > 0 {
1312		return invalidParams
1313	} else {
1314		return nil
1315	}
1316}
1317
1318func validateRunCommandTargets(v []types.RunCommandTarget) error {
1319	if v == nil {
1320		return nil
1321	}
1322	invalidParams := smithy.InvalidParamsError{Context: "RunCommandTargets"}
1323	for i := range v {
1324		if err := validateRunCommandTarget(&v[i]); err != nil {
1325			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1326		}
1327	}
1328	if invalidParams.Len() > 0 {
1329		return invalidParams
1330	} else {
1331		return nil
1332	}
1333}
1334
1335func validateSageMakerPipelineParameter(v *types.SageMakerPipelineParameter) error {
1336	if v == nil {
1337		return nil
1338	}
1339	invalidParams := smithy.InvalidParamsError{Context: "SageMakerPipelineParameter"}
1340	if v.Name == nil {
1341		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1342	}
1343	if v.Value == nil {
1344		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1345	}
1346	if invalidParams.Len() > 0 {
1347		return invalidParams
1348	} else {
1349		return nil
1350	}
1351}
1352
1353func validateSageMakerPipelineParameterList(v []types.SageMakerPipelineParameter) error {
1354	if v == nil {
1355		return nil
1356	}
1357	invalidParams := smithy.InvalidParamsError{Context: "SageMakerPipelineParameterList"}
1358	for i := range v {
1359		if err := validateSageMakerPipelineParameter(&v[i]); err != nil {
1360			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1361		}
1362	}
1363	if invalidParams.Len() > 0 {
1364		return invalidParams
1365	} else {
1366		return nil
1367	}
1368}
1369
1370func validateSageMakerPipelineParameters(v *types.SageMakerPipelineParameters) error {
1371	if v == nil {
1372		return nil
1373	}
1374	invalidParams := smithy.InvalidParamsError{Context: "SageMakerPipelineParameters"}
1375	if v.PipelineParameterList != nil {
1376		if err := validateSageMakerPipelineParameterList(v.PipelineParameterList); err != nil {
1377			invalidParams.AddNested("PipelineParameterList", err.(smithy.InvalidParamsError))
1378		}
1379	}
1380	if invalidParams.Len() > 0 {
1381		return invalidParams
1382	} else {
1383		return nil
1384	}
1385}
1386
1387func validateTag(v *types.Tag) error {
1388	if v == nil {
1389		return nil
1390	}
1391	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
1392	if v.Key == nil {
1393		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1394	}
1395	if v.Value == nil {
1396		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1397	}
1398	if invalidParams.Len() > 0 {
1399		return invalidParams
1400	} else {
1401		return nil
1402	}
1403}
1404
1405func validateTagList(v []types.Tag) error {
1406	if v == nil {
1407		return nil
1408	}
1409	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
1410	for i := range v {
1411		if err := validateTag(&v[i]); err != nil {
1412			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1413		}
1414	}
1415	if invalidParams.Len() > 0 {
1416		return invalidParams
1417	} else {
1418		return nil
1419	}
1420}
1421
1422func validateTarget(v *types.Target) error {
1423	if v == nil {
1424		return nil
1425	}
1426	invalidParams := smithy.InvalidParamsError{Context: "Target"}
1427	if v.Id == nil {
1428		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1429	}
1430	if v.Arn == nil {
1431		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
1432	}
1433	if v.InputTransformer != nil {
1434		if err := validateInputTransformer(v.InputTransformer); err != nil {
1435			invalidParams.AddNested("InputTransformer", err.(smithy.InvalidParamsError))
1436		}
1437	}
1438	if v.KinesisParameters != nil {
1439		if err := validateKinesisParameters(v.KinesisParameters); err != nil {
1440			invalidParams.AddNested("KinesisParameters", err.(smithy.InvalidParamsError))
1441		}
1442	}
1443	if v.RunCommandParameters != nil {
1444		if err := validateRunCommandParameters(v.RunCommandParameters); err != nil {
1445			invalidParams.AddNested("RunCommandParameters", err.(smithy.InvalidParamsError))
1446		}
1447	}
1448	if v.EcsParameters != nil {
1449		if err := validateEcsParameters(v.EcsParameters); err != nil {
1450			invalidParams.AddNested("EcsParameters", err.(smithy.InvalidParamsError))
1451		}
1452	}
1453	if v.BatchParameters != nil {
1454		if err := validateBatchParameters(v.BatchParameters); err != nil {
1455			invalidParams.AddNested("BatchParameters", err.(smithy.InvalidParamsError))
1456		}
1457	}
1458	if v.RedshiftDataParameters != nil {
1459		if err := validateRedshiftDataParameters(v.RedshiftDataParameters); err != nil {
1460			invalidParams.AddNested("RedshiftDataParameters", err.(smithy.InvalidParamsError))
1461		}
1462	}
1463	if v.SageMakerPipelineParameters != nil {
1464		if err := validateSageMakerPipelineParameters(v.SageMakerPipelineParameters); err != nil {
1465			invalidParams.AddNested("SageMakerPipelineParameters", err.(smithy.InvalidParamsError))
1466		}
1467	}
1468	if invalidParams.Len() > 0 {
1469		return invalidParams
1470	} else {
1471		return nil
1472	}
1473}
1474
1475func validateTargetList(v []types.Target) error {
1476	if v == nil {
1477		return nil
1478	}
1479	invalidParams := smithy.InvalidParamsError{Context: "TargetList"}
1480	for i := range v {
1481		if err := validateTarget(&v[i]); err != nil {
1482			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1483		}
1484	}
1485	if invalidParams.Len() > 0 {
1486		return invalidParams
1487	} else {
1488		return nil
1489	}
1490}
1491
1492func validateOpActivateEventSourceInput(v *ActivateEventSourceInput) error {
1493	if v == nil {
1494		return nil
1495	}
1496	invalidParams := smithy.InvalidParamsError{Context: "ActivateEventSourceInput"}
1497	if v.Name == nil {
1498		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1499	}
1500	if invalidParams.Len() > 0 {
1501		return invalidParams
1502	} else {
1503		return nil
1504	}
1505}
1506
1507func validateOpCancelReplayInput(v *CancelReplayInput) error {
1508	if v == nil {
1509		return nil
1510	}
1511	invalidParams := smithy.InvalidParamsError{Context: "CancelReplayInput"}
1512	if v.ReplayName == nil {
1513		invalidParams.Add(smithy.NewErrParamRequired("ReplayName"))
1514	}
1515	if invalidParams.Len() > 0 {
1516		return invalidParams
1517	} else {
1518		return nil
1519	}
1520}
1521
1522func validateOpCreateApiDestinationInput(v *CreateApiDestinationInput) error {
1523	if v == nil {
1524		return nil
1525	}
1526	invalidParams := smithy.InvalidParamsError{Context: "CreateApiDestinationInput"}
1527	if v.Name == nil {
1528		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1529	}
1530	if v.ConnectionArn == nil {
1531		invalidParams.Add(smithy.NewErrParamRequired("ConnectionArn"))
1532	}
1533	if v.InvocationEndpoint == nil {
1534		invalidParams.Add(smithy.NewErrParamRequired("InvocationEndpoint"))
1535	}
1536	if len(v.HttpMethod) == 0 {
1537		invalidParams.Add(smithy.NewErrParamRequired("HttpMethod"))
1538	}
1539	if invalidParams.Len() > 0 {
1540		return invalidParams
1541	} else {
1542		return nil
1543	}
1544}
1545
1546func validateOpCreateArchiveInput(v *CreateArchiveInput) error {
1547	if v == nil {
1548		return nil
1549	}
1550	invalidParams := smithy.InvalidParamsError{Context: "CreateArchiveInput"}
1551	if v.ArchiveName == nil {
1552		invalidParams.Add(smithy.NewErrParamRequired("ArchiveName"))
1553	}
1554	if v.EventSourceArn == nil {
1555		invalidParams.Add(smithy.NewErrParamRequired("EventSourceArn"))
1556	}
1557	if invalidParams.Len() > 0 {
1558		return invalidParams
1559	} else {
1560		return nil
1561	}
1562}
1563
1564func validateOpCreateConnectionInput(v *CreateConnectionInput) error {
1565	if v == nil {
1566		return nil
1567	}
1568	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionInput"}
1569	if v.Name == nil {
1570		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1571	}
1572	if len(v.AuthorizationType) == 0 {
1573		invalidParams.Add(smithy.NewErrParamRequired("AuthorizationType"))
1574	}
1575	if v.AuthParameters == nil {
1576		invalidParams.Add(smithy.NewErrParamRequired("AuthParameters"))
1577	} else if v.AuthParameters != nil {
1578		if err := validateCreateConnectionAuthRequestParameters(v.AuthParameters); err != nil {
1579			invalidParams.AddNested("AuthParameters", err.(smithy.InvalidParamsError))
1580		}
1581	}
1582	if invalidParams.Len() > 0 {
1583		return invalidParams
1584	} else {
1585		return nil
1586	}
1587}
1588
1589func validateOpCreateEventBusInput(v *CreateEventBusInput) error {
1590	if v == nil {
1591		return nil
1592	}
1593	invalidParams := smithy.InvalidParamsError{Context: "CreateEventBusInput"}
1594	if v.Name == nil {
1595		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1596	}
1597	if v.Tags != nil {
1598		if err := validateTagList(v.Tags); err != nil {
1599			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1600		}
1601	}
1602	if invalidParams.Len() > 0 {
1603		return invalidParams
1604	} else {
1605		return nil
1606	}
1607}
1608
1609func validateOpCreatePartnerEventSourceInput(v *CreatePartnerEventSourceInput) error {
1610	if v == nil {
1611		return nil
1612	}
1613	invalidParams := smithy.InvalidParamsError{Context: "CreatePartnerEventSourceInput"}
1614	if v.Name == nil {
1615		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1616	}
1617	if v.Account == nil {
1618		invalidParams.Add(smithy.NewErrParamRequired("Account"))
1619	}
1620	if invalidParams.Len() > 0 {
1621		return invalidParams
1622	} else {
1623		return nil
1624	}
1625}
1626
1627func validateOpDeactivateEventSourceInput(v *DeactivateEventSourceInput) error {
1628	if v == nil {
1629		return nil
1630	}
1631	invalidParams := smithy.InvalidParamsError{Context: "DeactivateEventSourceInput"}
1632	if v.Name == nil {
1633		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1634	}
1635	if invalidParams.Len() > 0 {
1636		return invalidParams
1637	} else {
1638		return nil
1639	}
1640}
1641
1642func validateOpDeauthorizeConnectionInput(v *DeauthorizeConnectionInput) error {
1643	if v == nil {
1644		return nil
1645	}
1646	invalidParams := smithy.InvalidParamsError{Context: "DeauthorizeConnectionInput"}
1647	if v.Name == nil {
1648		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1649	}
1650	if invalidParams.Len() > 0 {
1651		return invalidParams
1652	} else {
1653		return nil
1654	}
1655}
1656
1657func validateOpDeleteApiDestinationInput(v *DeleteApiDestinationInput) error {
1658	if v == nil {
1659		return nil
1660	}
1661	invalidParams := smithy.InvalidParamsError{Context: "DeleteApiDestinationInput"}
1662	if v.Name == nil {
1663		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1664	}
1665	if invalidParams.Len() > 0 {
1666		return invalidParams
1667	} else {
1668		return nil
1669	}
1670}
1671
1672func validateOpDeleteArchiveInput(v *DeleteArchiveInput) error {
1673	if v == nil {
1674		return nil
1675	}
1676	invalidParams := smithy.InvalidParamsError{Context: "DeleteArchiveInput"}
1677	if v.ArchiveName == nil {
1678		invalidParams.Add(smithy.NewErrParamRequired("ArchiveName"))
1679	}
1680	if invalidParams.Len() > 0 {
1681		return invalidParams
1682	} else {
1683		return nil
1684	}
1685}
1686
1687func validateOpDeleteConnectionInput(v *DeleteConnectionInput) error {
1688	if v == nil {
1689		return nil
1690	}
1691	invalidParams := smithy.InvalidParamsError{Context: "DeleteConnectionInput"}
1692	if v.Name == nil {
1693		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1694	}
1695	if invalidParams.Len() > 0 {
1696		return invalidParams
1697	} else {
1698		return nil
1699	}
1700}
1701
1702func validateOpDeleteEventBusInput(v *DeleteEventBusInput) error {
1703	if v == nil {
1704		return nil
1705	}
1706	invalidParams := smithy.InvalidParamsError{Context: "DeleteEventBusInput"}
1707	if v.Name == nil {
1708		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1709	}
1710	if invalidParams.Len() > 0 {
1711		return invalidParams
1712	} else {
1713		return nil
1714	}
1715}
1716
1717func validateOpDeletePartnerEventSourceInput(v *DeletePartnerEventSourceInput) error {
1718	if v == nil {
1719		return nil
1720	}
1721	invalidParams := smithy.InvalidParamsError{Context: "DeletePartnerEventSourceInput"}
1722	if v.Name == nil {
1723		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1724	}
1725	if v.Account == nil {
1726		invalidParams.Add(smithy.NewErrParamRequired("Account"))
1727	}
1728	if invalidParams.Len() > 0 {
1729		return invalidParams
1730	} else {
1731		return nil
1732	}
1733}
1734
1735func validateOpDeleteRuleInput(v *DeleteRuleInput) error {
1736	if v == nil {
1737		return nil
1738	}
1739	invalidParams := smithy.InvalidParamsError{Context: "DeleteRuleInput"}
1740	if v.Name == nil {
1741		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1742	}
1743	if invalidParams.Len() > 0 {
1744		return invalidParams
1745	} else {
1746		return nil
1747	}
1748}
1749
1750func validateOpDescribeApiDestinationInput(v *DescribeApiDestinationInput) error {
1751	if v == nil {
1752		return nil
1753	}
1754	invalidParams := smithy.InvalidParamsError{Context: "DescribeApiDestinationInput"}
1755	if v.Name == nil {
1756		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1757	}
1758	if invalidParams.Len() > 0 {
1759		return invalidParams
1760	} else {
1761		return nil
1762	}
1763}
1764
1765func validateOpDescribeArchiveInput(v *DescribeArchiveInput) error {
1766	if v == nil {
1767		return nil
1768	}
1769	invalidParams := smithy.InvalidParamsError{Context: "DescribeArchiveInput"}
1770	if v.ArchiveName == nil {
1771		invalidParams.Add(smithy.NewErrParamRequired("ArchiveName"))
1772	}
1773	if invalidParams.Len() > 0 {
1774		return invalidParams
1775	} else {
1776		return nil
1777	}
1778}
1779
1780func validateOpDescribeConnectionInput(v *DescribeConnectionInput) error {
1781	if v == nil {
1782		return nil
1783	}
1784	invalidParams := smithy.InvalidParamsError{Context: "DescribeConnectionInput"}
1785	if v.Name == nil {
1786		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1787	}
1788	if invalidParams.Len() > 0 {
1789		return invalidParams
1790	} else {
1791		return nil
1792	}
1793}
1794
1795func validateOpDescribeEventSourceInput(v *DescribeEventSourceInput) error {
1796	if v == nil {
1797		return nil
1798	}
1799	invalidParams := smithy.InvalidParamsError{Context: "DescribeEventSourceInput"}
1800	if v.Name == nil {
1801		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1802	}
1803	if invalidParams.Len() > 0 {
1804		return invalidParams
1805	} else {
1806		return nil
1807	}
1808}
1809
1810func validateOpDescribePartnerEventSourceInput(v *DescribePartnerEventSourceInput) error {
1811	if v == nil {
1812		return nil
1813	}
1814	invalidParams := smithy.InvalidParamsError{Context: "DescribePartnerEventSourceInput"}
1815	if v.Name == nil {
1816		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1817	}
1818	if invalidParams.Len() > 0 {
1819		return invalidParams
1820	} else {
1821		return nil
1822	}
1823}
1824
1825func validateOpDescribeReplayInput(v *DescribeReplayInput) error {
1826	if v == nil {
1827		return nil
1828	}
1829	invalidParams := smithy.InvalidParamsError{Context: "DescribeReplayInput"}
1830	if v.ReplayName == nil {
1831		invalidParams.Add(smithy.NewErrParamRequired("ReplayName"))
1832	}
1833	if invalidParams.Len() > 0 {
1834		return invalidParams
1835	} else {
1836		return nil
1837	}
1838}
1839
1840func validateOpDescribeRuleInput(v *DescribeRuleInput) error {
1841	if v == nil {
1842		return nil
1843	}
1844	invalidParams := smithy.InvalidParamsError{Context: "DescribeRuleInput"}
1845	if v.Name == nil {
1846		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1847	}
1848	if invalidParams.Len() > 0 {
1849		return invalidParams
1850	} else {
1851		return nil
1852	}
1853}
1854
1855func validateOpDisableRuleInput(v *DisableRuleInput) error {
1856	if v == nil {
1857		return nil
1858	}
1859	invalidParams := smithy.InvalidParamsError{Context: "DisableRuleInput"}
1860	if v.Name == nil {
1861		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1862	}
1863	if invalidParams.Len() > 0 {
1864		return invalidParams
1865	} else {
1866		return nil
1867	}
1868}
1869
1870func validateOpEnableRuleInput(v *EnableRuleInput) error {
1871	if v == nil {
1872		return nil
1873	}
1874	invalidParams := smithy.InvalidParamsError{Context: "EnableRuleInput"}
1875	if v.Name == nil {
1876		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1877	}
1878	if invalidParams.Len() > 0 {
1879		return invalidParams
1880	} else {
1881		return nil
1882	}
1883}
1884
1885func validateOpListPartnerEventSourceAccountsInput(v *ListPartnerEventSourceAccountsInput) error {
1886	if v == nil {
1887		return nil
1888	}
1889	invalidParams := smithy.InvalidParamsError{Context: "ListPartnerEventSourceAccountsInput"}
1890	if v.EventSourceName == nil {
1891		invalidParams.Add(smithy.NewErrParamRequired("EventSourceName"))
1892	}
1893	if invalidParams.Len() > 0 {
1894		return invalidParams
1895	} else {
1896		return nil
1897	}
1898}
1899
1900func validateOpListPartnerEventSourcesInput(v *ListPartnerEventSourcesInput) error {
1901	if v == nil {
1902		return nil
1903	}
1904	invalidParams := smithy.InvalidParamsError{Context: "ListPartnerEventSourcesInput"}
1905	if v.NamePrefix == nil {
1906		invalidParams.Add(smithy.NewErrParamRequired("NamePrefix"))
1907	}
1908	if invalidParams.Len() > 0 {
1909		return invalidParams
1910	} else {
1911		return nil
1912	}
1913}
1914
1915func validateOpListRuleNamesByTargetInput(v *ListRuleNamesByTargetInput) error {
1916	if v == nil {
1917		return nil
1918	}
1919	invalidParams := smithy.InvalidParamsError{Context: "ListRuleNamesByTargetInput"}
1920	if v.TargetArn == nil {
1921		invalidParams.Add(smithy.NewErrParamRequired("TargetArn"))
1922	}
1923	if invalidParams.Len() > 0 {
1924		return invalidParams
1925	} else {
1926		return nil
1927	}
1928}
1929
1930func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1931	if v == nil {
1932		return nil
1933	}
1934	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1935	if v.ResourceARN == nil {
1936		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
1937	}
1938	if invalidParams.Len() > 0 {
1939		return invalidParams
1940	} else {
1941		return nil
1942	}
1943}
1944
1945func validateOpListTargetsByRuleInput(v *ListTargetsByRuleInput) error {
1946	if v == nil {
1947		return nil
1948	}
1949	invalidParams := smithy.InvalidParamsError{Context: "ListTargetsByRuleInput"}
1950	if v.Rule == nil {
1951		invalidParams.Add(smithy.NewErrParamRequired("Rule"))
1952	}
1953	if invalidParams.Len() > 0 {
1954		return invalidParams
1955	} else {
1956		return nil
1957	}
1958}
1959
1960func validateOpPutEventsInput(v *PutEventsInput) error {
1961	if v == nil {
1962		return nil
1963	}
1964	invalidParams := smithy.InvalidParamsError{Context: "PutEventsInput"}
1965	if v.Entries == nil {
1966		invalidParams.Add(smithy.NewErrParamRequired("Entries"))
1967	}
1968	if invalidParams.Len() > 0 {
1969		return invalidParams
1970	} else {
1971		return nil
1972	}
1973}
1974
1975func validateOpPutPartnerEventsInput(v *PutPartnerEventsInput) error {
1976	if v == nil {
1977		return nil
1978	}
1979	invalidParams := smithy.InvalidParamsError{Context: "PutPartnerEventsInput"}
1980	if v.Entries == nil {
1981		invalidParams.Add(smithy.NewErrParamRequired("Entries"))
1982	}
1983	if invalidParams.Len() > 0 {
1984		return invalidParams
1985	} else {
1986		return nil
1987	}
1988}
1989
1990func validateOpPutPermissionInput(v *PutPermissionInput) error {
1991	if v == nil {
1992		return nil
1993	}
1994	invalidParams := smithy.InvalidParamsError{Context: "PutPermissionInput"}
1995	if v.Condition != nil {
1996		if err := validateCondition(v.Condition); err != nil {
1997			invalidParams.AddNested("Condition", err.(smithy.InvalidParamsError))
1998		}
1999	}
2000	if invalidParams.Len() > 0 {
2001		return invalidParams
2002	} else {
2003		return nil
2004	}
2005}
2006
2007func validateOpPutRuleInput(v *PutRuleInput) error {
2008	if v == nil {
2009		return nil
2010	}
2011	invalidParams := smithy.InvalidParamsError{Context: "PutRuleInput"}
2012	if v.Name == nil {
2013		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2014	}
2015	if v.Tags != nil {
2016		if err := validateTagList(v.Tags); err != nil {
2017			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2018		}
2019	}
2020	if invalidParams.Len() > 0 {
2021		return invalidParams
2022	} else {
2023		return nil
2024	}
2025}
2026
2027func validateOpPutTargetsInput(v *PutTargetsInput) error {
2028	if v == nil {
2029		return nil
2030	}
2031	invalidParams := smithy.InvalidParamsError{Context: "PutTargetsInput"}
2032	if v.Rule == nil {
2033		invalidParams.Add(smithy.NewErrParamRequired("Rule"))
2034	}
2035	if v.Targets == nil {
2036		invalidParams.Add(smithy.NewErrParamRequired("Targets"))
2037	} else if v.Targets != nil {
2038		if err := validateTargetList(v.Targets); err != nil {
2039			invalidParams.AddNested("Targets", err.(smithy.InvalidParamsError))
2040		}
2041	}
2042	if invalidParams.Len() > 0 {
2043		return invalidParams
2044	} else {
2045		return nil
2046	}
2047}
2048
2049func validateOpRemoveTargetsInput(v *RemoveTargetsInput) error {
2050	if v == nil {
2051		return nil
2052	}
2053	invalidParams := smithy.InvalidParamsError{Context: "RemoveTargetsInput"}
2054	if v.Rule == nil {
2055		invalidParams.Add(smithy.NewErrParamRequired("Rule"))
2056	}
2057	if v.Ids == nil {
2058		invalidParams.Add(smithy.NewErrParamRequired("Ids"))
2059	}
2060	if invalidParams.Len() > 0 {
2061		return invalidParams
2062	} else {
2063		return nil
2064	}
2065}
2066
2067func validateOpStartReplayInput(v *StartReplayInput) error {
2068	if v == nil {
2069		return nil
2070	}
2071	invalidParams := smithy.InvalidParamsError{Context: "StartReplayInput"}
2072	if v.ReplayName == nil {
2073		invalidParams.Add(smithy.NewErrParamRequired("ReplayName"))
2074	}
2075	if v.EventSourceArn == nil {
2076		invalidParams.Add(smithy.NewErrParamRequired("EventSourceArn"))
2077	}
2078	if v.EventStartTime == nil {
2079		invalidParams.Add(smithy.NewErrParamRequired("EventStartTime"))
2080	}
2081	if v.EventEndTime == nil {
2082		invalidParams.Add(smithy.NewErrParamRequired("EventEndTime"))
2083	}
2084	if v.Destination == nil {
2085		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
2086	} else if v.Destination != nil {
2087		if err := validateReplayDestination(v.Destination); err != nil {
2088			invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError))
2089		}
2090	}
2091	if invalidParams.Len() > 0 {
2092		return invalidParams
2093	} else {
2094		return nil
2095	}
2096}
2097
2098func validateOpTagResourceInput(v *TagResourceInput) error {
2099	if v == nil {
2100		return nil
2101	}
2102	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
2103	if v.ResourceARN == nil {
2104		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
2105	}
2106	if v.Tags == nil {
2107		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
2108	} else if v.Tags != nil {
2109		if err := validateTagList(v.Tags); err != nil {
2110			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2111		}
2112	}
2113	if invalidParams.Len() > 0 {
2114		return invalidParams
2115	} else {
2116		return nil
2117	}
2118}
2119
2120func validateOpTestEventPatternInput(v *TestEventPatternInput) error {
2121	if v == nil {
2122		return nil
2123	}
2124	invalidParams := smithy.InvalidParamsError{Context: "TestEventPatternInput"}
2125	if v.EventPattern == nil {
2126		invalidParams.Add(smithy.NewErrParamRequired("EventPattern"))
2127	}
2128	if v.Event == nil {
2129		invalidParams.Add(smithy.NewErrParamRequired("Event"))
2130	}
2131	if invalidParams.Len() > 0 {
2132		return invalidParams
2133	} else {
2134		return nil
2135	}
2136}
2137
2138func validateOpUntagResourceInput(v *UntagResourceInput) error {
2139	if v == nil {
2140		return nil
2141	}
2142	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
2143	if v.ResourceARN == nil {
2144		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
2145	}
2146	if v.TagKeys == nil {
2147		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
2148	}
2149	if invalidParams.Len() > 0 {
2150		return invalidParams
2151	} else {
2152		return nil
2153	}
2154}
2155
2156func validateOpUpdateApiDestinationInput(v *UpdateApiDestinationInput) error {
2157	if v == nil {
2158		return nil
2159	}
2160	invalidParams := smithy.InvalidParamsError{Context: "UpdateApiDestinationInput"}
2161	if v.Name == nil {
2162		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2163	}
2164	if invalidParams.Len() > 0 {
2165		return invalidParams
2166	} else {
2167		return nil
2168	}
2169}
2170
2171func validateOpUpdateArchiveInput(v *UpdateArchiveInput) error {
2172	if v == nil {
2173		return nil
2174	}
2175	invalidParams := smithy.InvalidParamsError{Context: "UpdateArchiveInput"}
2176	if v.ArchiveName == nil {
2177		invalidParams.Add(smithy.NewErrParamRequired("ArchiveName"))
2178	}
2179	if invalidParams.Len() > 0 {
2180		return invalidParams
2181	} else {
2182		return nil
2183	}
2184}
2185
2186func validateOpUpdateConnectionInput(v *UpdateConnectionInput) error {
2187	if v == nil {
2188		return nil
2189	}
2190	invalidParams := smithy.InvalidParamsError{Context: "UpdateConnectionInput"}
2191	if v.Name == nil {
2192		invalidParams.Add(smithy.NewErrParamRequired("Name"))
2193	}
2194	if invalidParams.Len() > 0 {
2195		return invalidParams
2196	} else {
2197		return nil
2198	}
2199}
2200