1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package cloudwatchevents
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/cloudwatchevents/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 validateOpCreateArchive struct {
54}
55
56func (*validateOpCreateArchive) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpCreateArchive) 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.(*CreateArchiveInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpCreateArchiveInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateEventBus struct {
74}
75
76func (*validateOpCreateEventBus) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateEventBus) 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.(*CreateEventBusInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateEventBusInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreatePartnerEventSource struct {
94}
95
96func (*validateOpCreatePartnerEventSource) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreatePartnerEventSource) 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.(*CreatePartnerEventSourceInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreatePartnerEventSourceInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpDeactivateEventSource struct {
114}
115
116func (*validateOpDeactivateEventSource) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpDeactivateEventSource) 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.(*DeactivateEventSourceInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpDeactivateEventSourceInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDeleteArchive struct {
134}
135
136func (*validateOpDeleteArchive) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDeleteArchive) 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.(*DeleteArchiveInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDeleteArchiveInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDeleteEventBus struct {
154}
155
156func (*validateOpDeleteEventBus) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDeleteEventBus) 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.(*DeleteEventBusInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDeleteEventBusInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDeletePartnerEventSource struct {
174}
175
176func (*validateOpDeletePartnerEventSource) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDeletePartnerEventSource) 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.(*DeletePartnerEventSourceInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDeletePartnerEventSourceInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDeleteRule struct {
194}
195
196func (*validateOpDeleteRule) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDeleteRule) 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.(*DeleteRuleInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDeleteRuleInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpDescribeArchive struct {
214}
215
216func (*validateOpDescribeArchive) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpDescribeArchive) 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.(*DescribeArchiveInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpDescribeArchiveInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDescribeEventSource struct {
234}
235
236func (*validateOpDescribeEventSource) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDescribeEventSource) 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.(*DescribeEventSourceInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDescribeEventSourceInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDescribePartnerEventSource struct {
254}
255
256func (*validateOpDescribePartnerEventSource) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDescribePartnerEventSource) 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.(*DescribePartnerEventSourceInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDescribePartnerEventSourceInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDescribeReplay struct {
274}
275
276func (*validateOpDescribeReplay) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDescribeReplay) 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.(*DescribeReplayInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDescribeReplayInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDescribeRule struct {
294}
295
296func (*validateOpDescribeRule) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDescribeRule) 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.(*DescribeRuleInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDescribeRuleInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDisableRule struct {
314}
315
316func (*validateOpDisableRule) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDisableRule) 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.(*DisableRuleInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDisableRuleInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpEnableRule struct {
334}
335
336func (*validateOpEnableRule) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpEnableRule) 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.(*EnableRuleInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpEnableRuleInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpListPartnerEventSourceAccounts struct {
354}
355
356func (*validateOpListPartnerEventSourceAccounts) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpListPartnerEventSourceAccounts) 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.(*ListPartnerEventSourceAccountsInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpListPartnerEventSourceAccountsInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpListPartnerEventSources struct {
374}
375
376func (*validateOpListPartnerEventSources) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpListPartnerEventSources) 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.(*ListPartnerEventSourcesInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpListPartnerEventSourcesInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpListRuleNamesByTarget struct {
394}
395
396func (*validateOpListRuleNamesByTarget) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpListRuleNamesByTarget) 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.(*ListRuleNamesByTargetInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpListRuleNamesByTargetInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpListTagsForResource struct {
414}
415
416func (*validateOpListTagsForResource) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpListTagsForResourceInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpListTargetsByRule struct {
434}
435
436func (*validateOpListTargetsByRule) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpListTargetsByRule) 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.(*ListTargetsByRuleInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpListTargetsByRuleInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpPutEvents struct {
454}
455
456func (*validateOpPutEvents) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpPutEvents) 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.(*PutEventsInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpPutEventsInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpPutPartnerEvents struct {
474}
475
476func (*validateOpPutPartnerEvents) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpPutPartnerEvents) 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.(*PutPartnerEventsInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpPutPartnerEventsInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpPutPermission struct {
494}
495
496func (*validateOpPutPermission) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpPutPermission) 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.(*PutPermissionInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpPutPermissionInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpPutRule struct {
514}
515
516func (*validateOpPutRule) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpPutRule) 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.(*PutRuleInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpPutRuleInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpPutTargets struct {
534}
535
536func (*validateOpPutTargets) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpPutTargets) 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.(*PutTargetsInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpPutTargetsInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpRemoveTargets struct {
554}
555
556func (*validateOpRemoveTargets) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpRemoveTargets) 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.(*RemoveTargetsInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpRemoveTargetsInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpStartReplay struct {
574}
575
576func (*validateOpStartReplay) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpStartReplay) 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.(*StartReplayInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpStartReplayInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpTagResource struct {
594}
595
596func (*validateOpTagResource) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpTagResource) 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.(*TagResourceInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpTagResourceInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpTestEventPattern struct {
614}
615
616func (*validateOpTestEventPattern) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpTestEventPattern) 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.(*TestEventPatternInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpTestEventPatternInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpUntagResource struct {
634}
635
636func (*validateOpUntagResource) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpUntagResource) 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.(*UntagResourceInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpUntagResourceInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpUpdateArchive struct {
654}
655
656func (*validateOpUpdateArchive) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpUpdateArchive) 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.(*UpdateArchiveInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpUpdateArchiveInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673func addOpActivateEventSourceValidationMiddleware(stack *middleware.Stack) error {
674	return stack.Initialize.Add(&validateOpActivateEventSource{}, middleware.After)
675}
676
677func addOpCancelReplayValidationMiddleware(stack *middleware.Stack) error {
678	return stack.Initialize.Add(&validateOpCancelReplay{}, middleware.After)
679}
680
681func addOpCreateArchiveValidationMiddleware(stack *middleware.Stack) error {
682	return stack.Initialize.Add(&validateOpCreateArchive{}, middleware.After)
683}
684
685func addOpCreateEventBusValidationMiddleware(stack *middleware.Stack) error {
686	return stack.Initialize.Add(&validateOpCreateEventBus{}, middleware.After)
687}
688
689func addOpCreatePartnerEventSourceValidationMiddleware(stack *middleware.Stack) error {
690	return stack.Initialize.Add(&validateOpCreatePartnerEventSource{}, middleware.After)
691}
692
693func addOpDeactivateEventSourceValidationMiddleware(stack *middleware.Stack) error {
694	return stack.Initialize.Add(&validateOpDeactivateEventSource{}, middleware.After)
695}
696
697func addOpDeleteArchiveValidationMiddleware(stack *middleware.Stack) error {
698	return stack.Initialize.Add(&validateOpDeleteArchive{}, middleware.After)
699}
700
701func addOpDeleteEventBusValidationMiddleware(stack *middleware.Stack) error {
702	return stack.Initialize.Add(&validateOpDeleteEventBus{}, middleware.After)
703}
704
705func addOpDeletePartnerEventSourceValidationMiddleware(stack *middleware.Stack) error {
706	return stack.Initialize.Add(&validateOpDeletePartnerEventSource{}, middleware.After)
707}
708
709func addOpDeleteRuleValidationMiddleware(stack *middleware.Stack) error {
710	return stack.Initialize.Add(&validateOpDeleteRule{}, middleware.After)
711}
712
713func addOpDescribeArchiveValidationMiddleware(stack *middleware.Stack) error {
714	return stack.Initialize.Add(&validateOpDescribeArchive{}, middleware.After)
715}
716
717func addOpDescribeEventSourceValidationMiddleware(stack *middleware.Stack) error {
718	return stack.Initialize.Add(&validateOpDescribeEventSource{}, middleware.After)
719}
720
721func addOpDescribePartnerEventSourceValidationMiddleware(stack *middleware.Stack) error {
722	return stack.Initialize.Add(&validateOpDescribePartnerEventSource{}, middleware.After)
723}
724
725func addOpDescribeReplayValidationMiddleware(stack *middleware.Stack) error {
726	return stack.Initialize.Add(&validateOpDescribeReplay{}, middleware.After)
727}
728
729func addOpDescribeRuleValidationMiddleware(stack *middleware.Stack) error {
730	return stack.Initialize.Add(&validateOpDescribeRule{}, middleware.After)
731}
732
733func addOpDisableRuleValidationMiddleware(stack *middleware.Stack) error {
734	return stack.Initialize.Add(&validateOpDisableRule{}, middleware.After)
735}
736
737func addOpEnableRuleValidationMiddleware(stack *middleware.Stack) error {
738	return stack.Initialize.Add(&validateOpEnableRule{}, middleware.After)
739}
740
741func addOpListPartnerEventSourceAccountsValidationMiddleware(stack *middleware.Stack) error {
742	return stack.Initialize.Add(&validateOpListPartnerEventSourceAccounts{}, middleware.After)
743}
744
745func addOpListPartnerEventSourcesValidationMiddleware(stack *middleware.Stack) error {
746	return stack.Initialize.Add(&validateOpListPartnerEventSources{}, middleware.After)
747}
748
749func addOpListRuleNamesByTargetValidationMiddleware(stack *middleware.Stack) error {
750	return stack.Initialize.Add(&validateOpListRuleNamesByTarget{}, middleware.After)
751}
752
753func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
754	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
755}
756
757func addOpListTargetsByRuleValidationMiddleware(stack *middleware.Stack) error {
758	return stack.Initialize.Add(&validateOpListTargetsByRule{}, middleware.After)
759}
760
761func addOpPutEventsValidationMiddleware(stack *middleware.Stack) error {
762	return stack.Initialize.Add(&validateOpPutEvents{}, middleware.After)
763}
764
765func addOpPutPartnerEventsValidationMiddleware(stack *middleware.Stack) error {
766	return stack.Initialize.Add(&validateOpPutPartnerEvents{}, middleware.After)
767}
768
769func addOpPutPermissionValidationMiddleware(stack *middleware.Stack) error {
770	return stack.Initialize.Add(&validateOpPutPermission{}, middleware.After)
771}
772
773func addOpPutRuleValidationMiddleware(stack *middleware.Stack) error {
774	return stack.Initialize.Add(&validateOpPutRule{}, middleware.After)
775}
776
777func addOpPutTargetsValidationMiddleware(stack *middleware.Stack) error {
778	return stack.Initialize.Add(&validateOpPutTargets{}, middleware.After)
779}
780
781func addOpRemoveTargetsValidationMiddleware(stack *middleware.Stack) error {
782	return stack.Initialize.Add(&validateOpRemoveTargets{}, middleware.After)
783}
784
785func addOpStartReplayValidationMiddleware(stack *middleware.Stack) error {
786	return stack.Initialize.Add(&validateOpStartReplay{}, middleware.After)
787}
788
789func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
790	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
791}
792
793func addOpTestEventPatternValidationMiddleware(stack *middleware.Stack) error {
794	return stack.Initialize.Add(&validateOpTestEventPattern{}, middleware.After)
795}
796
797func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
798	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
799}
800
801func addOpUpdateArchiveValidationMiddleware(stack *middleware.Stack) error {
802	return stack.Initialize.Add(&validateOpUpdateArchive{}, middleware.After)
803}
804
805func validateAwsVpcConfiguration(v *types.AwsVpcConfiguration) error {
806	if v == nil {
807		return nil
808	}
809	invalidParams := smithy.InvalidParamsError{Context: "AwsVpcConfiguration"}
810	if v.Subnets == nil {
811		invalidParams.Add(smithy.NewErrParamRequired("Subnets"))
812	}
813	if invalidParams.Len() > 0 {
814		return invalidParams
815	} else {
816		return nil
817	}
818}
819
820func validateBatchParameters(v *types.BatchParameters) error {
821	if v == nil {
822		return nil
823	}
824	invalidParams := smithy.InvalidParamsError{Context: "BatchParameters"}
825	if v.JobDefinition == nil {
826		invalidParams.Add(smithy.NewErrParamRequired("JobDefinition"))
827	}
828	if v.JobName == nil {
829		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
830	}
831	if invalidParams.Len() > 0 {
832		return invalidParams
833	} else {
834		return nil
835	}
836}
837
838func validateCondition(v *types.Condition) error {
839	if v == nil {
840		return nil
841	}
842	invalidParams := smithy.InvalidParamsError{Context: "Condition"}
843	if v.Type == nil {
844		invalidParams.Add(smithy.NewErrParamRequired("Type"))
845	}
846	if v.Key == nil {
847		invalidParams.Add(smithy.NewErrParamRequired("Key"))
848	}
849	if v.Value == nil {
850		invalidParams.Add(smithy.NewErrParamRequired("Value"))
851	}
852	if invalidParams.Len() > 0 {
853		return invalidParams
854	} else {
855		return nil
856	}
857}
858
859func validateEcsParameters(v *types.EcsParameters) error {
860	if v == nil {
861		return nil
862	}
863	invalidParams := smithy.InvalidParamsError{Context: "EcsParameters"}
864	if v.TaskDefinitionArn == nil {
865		invalidParams.Add(smithy.NewErrParamRequired("TaskDefinitionArn"))
866	}
867	if v.NetworkConfiguration != nil {
868		if err := validateNetworkConfiguration(v.NetworkConfiguration); err != nil {
869			invalidParams.AddNested("NetworkConfiguration", err.(smithy.InvalidParamsError))
870		}
871	}
872	if invalidParams.Len() > 0 {
873		return invalidParams
874	} else {
875		return nil
876	}
877}
878
879func validateInputTransformer(v *types.InputTransformer) error {
880	if v == nil {
881		return nil
882	}
883	invalidParams := smithy.InvalidParamsError{Context: "InputTransformer"}
884	if v.InputTemplate == nil {
885		invalidParams.Add(smithy.NewErrParamRequired("InputTemplate"))
886	}
887	if invalidParams.Len() > 0 {
888		return invalidParams
889	} else {
890		return nil
891	}
892}
893
894func validateKinesisParameters(v *types.KinesisParameters) error {
895	if v == nil {
896		return nil
897	}
898	invalidParams := smithy.InvalidParamsError{Context: "KinesisParameters"}
899	if v.PartitionKeyPath == nil {
900		invalidParams.Add(smithy.NewErrParamRequired("PartitionKeyPath"))
901	}
902	if invalidParams.Len() > 0 {
903		return invalidParams
904	} else {
905		return nil
906	}
907}
908
909func validateNetworkConfiguration(v *types.NetworkConfiguration) error {
910	if v == nil {
911		return nil
912	}
913	invalidParams := smithy.InvalidParamsError{Context: "NetworkConfiguration"}
914	if v.AwsvpcConfiguration != nil {
915		if err := validateAwsVpcConfiguration(v.AwsvpcConfiguration); err != nil {
916			invalidParams.AddNested("AwsvpcConfiguration", err.(smithy.InvalidParamsError))
917		}
918	}
919	if invalidParams.Len() > 0 {
920		return invalidParams
921	} else {
922		return nil
923	}
924}
925
926func validateRedshiftDataParameters(v *types.RedshiftDataParameters) error {
927	if v == nil {
928		return nil
929	}
930	invalidParams := smithy.InvalidParamsError{Context: "RedshiftDataParameters"}
931	if v.Database == nil {
932		invalidParams.Add(smithy.NewErrParamRequired("Database"))
933	}
934	if v.Sql == nil {
935		invalidParams.Add(smithy.NewErrParamRequired("Sql"))
936	}
937	if invalidParams.Len() > 0 {
938		return invalidParams
939	} else {
940		return nil
941	}
942}
943
944func validateReplayDestination(v *types.ReplayDestination) error {
945	if v == nil {
946		return nil
947	}
948	invalidParams := smithy.InvalidParamsError{Context: "ReplayDestination"}
949	if v.Arn == nil {
950		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
951	}
952	if invalidParams.Len() > 0 {
953		return invalidParams
954	} else {
955		return nil
956	}
957}
958
959func validateRunCommandParameters(v *types.RunCommandParameters) error {
960	if v == nil {
961		return nil
962	}
963	invalidParams := smithy.InvalidParamsError{Context: "RunCommandParameters"}
964	if v.RunCommandTargets == nil {
965		invalidParams.Add(smithy.NewErrParamRequired("RunCommandTargets"))
966	} else if v.RunCommandTargets != nil {
967		if err := validateRunCommandTargets(v.RunCommandTargets); err != nil {
968			invalidParams.AddNested("RunCommandTargets", err.(smithy.InvalidParamsError))
969		}
970	}
971	if invalidParams.Len() > 0 {
972		return invalidParams
973	} else {
974		return nil
975	}
976}
977
978func validateRunCommandTarget(v *types.RunCommandTarget) error {
979	if v == nil {
980		return nil
981	}
982	invalidParams := smithy.InvalidParamsError{Context: "RunCommandTarget"}
983	if v.Key == nil {
984		invalidParams.Add(smithy.NewErrParamRequired("Key"))
985	}
986	if v.Values == nil {
987		invalidParams.Add(smithy.NewErrParamRequired("Values"))
988	}
989	if invalidParams.Len() > 0 {
990		return invalidParams
991	} else {
992		return nil
993	}
994}
995
996func validateRunCommandTargets(v []types.RunCommandTarget) error {
997	if v == nil {
998		return nil
999	}
1000	invalidParams := smithy.InvalidParamsError{Context: "RunCommandTargets"}
1001	for i := range v {
1002		if err := validateRunCommandTarget(&v[i]); err != nil {
1003			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1004		}
1005	}
1006	if invalidParams.Len() > 0 {
1007		return invalidParams
1008	} else {
1009		return nil
1010	}
1011}
1012
1013func validateTag(v *types.Tag) error {
1014	if v == nil {
1015		return nil
1016	}
1017	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
1018	if v.Key == nil {
1019		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1020	}
1021	if v.Value == nil {
1022		invalidParams.Add(smithy.NewErrParamRequired("Value"))
1023	}
1024	if invalidParams.Len() > 0 {
1025		return invalidParams
1026	} else {
1027		return nil
1028	}
1029}
1030
1031func validateTagList(v []types.Tag) error {
1032	if v == nil {
1033		return nil
1034	}
1035	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
1036	for i := range v {
1037		if err := validateTag(&v[i]); err != nil {
1038			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1039		}
1040	}
1041	if invalidParams.Len() > 0 {
1042		return invalidParams
1043	} else {
1044		return nil
1045	}
1046}
1047
1048func validateTarget(v *types.Target) error {
1049	if v == nil {
1050		return nil
1051	}
1052	invalidParams := smithy.InvalidParamsError{Context: "Target"}
1053	if v.Id == nil {
1054		invalidParams.Add(smithy.NewErrParamRequired("Id"))
1055	}
1056	if v.Arn == nil {
1057		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
1058	}
1059	if v.InputTransformer != nil {
1060		if err := validateInputTransformer(v.InputTransformer); err != nil {
1061			invalidParams.AddNested("InputTransformer", err.(smithy.InvalidParamsError))
1062		}
1063	}
1064	if v.KinesisParameters != nil {
1065		if err := validateKinesisParameters(v.KinesisParameters); err != nil {
1066			invalidParams.AddNested("KinesisParameters", err.(smithy.InvalidParamsError))
1067		}
1068	}
1069	if v.RunCommandParameters != nil {
1070		if err := validateRunCommandParameters(v.RunCommandParameters); err != nil {
1071			invalidParams.AddNested("RunCommandParameters", err.(smithy.InvalidParamsError))
1072		}
1073	}
1074	if v.EcsParameters != nil {
1075		if err := validateEcsParameters(v.EcsParameters); err != nil {
1076			invalidParams.AddNested("EcsParameters", err.(smithy.InvalidParamsError))
1077		}
1078	}
1079	if v.BatchParameters != nil {
1080		if err := validateBatchParameters(v.BatchParameters); err != nil {
1081			invalidParams.AddNested("BatchParameters", err.(smithy.InvalidParamsError))
1082		}
1083	}
1084	if v.RedshiftDataParameters != nil {
1085		if err := validateRedshiftDataParameters(v.RedshiftDataParameters); err != nil {
1086			invalidParams.AddNested("RedshiftDataParameters", err.(smithy.InvalidParamsError))
1087		}
1088	}
1089	if invalidParams.Len() > 0 {
1090		return invalidParams
1091	} else {
1092		return nil
1093	}
1094}
1095
1096func validateTargetList(v []types.Target) error {
1097	if v == nil {
1098		return nil
1099	}
1100	invalidParams := smithy.InvalidParamsError{Context: "TargetList"}
1101	for i := range v {
1102		if err := validateTarget(&v[i]); err != nil {
1103			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1104		}
1105	}
1106	if invalidParams.Len() > 0 {
1107		return invalidParams
1108	} else {
1109		return nil
1110	}
1111}
1112
1113func validateOpActivateEventSourceInput(v *ActivateEventSourceInput) error {
1114	if v == nil {
1115		return nil
1116	}
1117	invalidParams := smithy.InvalidParamsError{Context: "ActivateEventSourceInput"}
1118	if v.Name == nil {
1119		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1120	}
1121	if invalidParams.Len() > 0 {
1122		return invalidParams
1123	} else {
1124		return nil
1125	}
1126}
1127
1128func validateOpCancelReplayInput(v *CancelReplayInput) error {
1129	if v == nil {
1130		return nil
1131	}
1132	invalidParams := smithy.InvalidParamsError{Context: "CancelReplayInput"}
1133	if v.ReplayName == nil {
1134		invalidParams.Add(smithy.NewErrParamRequired("ReplayName"))
1135	}
1136	if invalidParams.Len() > 0 {
1137		return invalidParams
1138	} else {
1139		return nil
1140	}
1141}
1142
1143func validateOpCreateArchiveInput(v *CreateArchiveInput) error {
1144	if v == nil {
1145		return nil
1146	}
1147	invalidParams := smithy.InvalidParamsError{Context: "CreateArchiveInput"}
1148	if v.ArchiveName == nil {
1149		invalidParams.Add(smithy.NewErrParamRequired("ArchiveName"))
1150	}
1151	if v.EventSourceArn == nil {
1152		invalidParams.Add(smithy.NewErrParamRequired("EventSourceArn"))
1153	}
1154	if invalidParams.Len() > 0 {
1155		return invalidParams
1156	} else {
1157		return nil
1158	}
1159}
1160
1161func validateOpCreateEventBusInput(v *CreateEventBusInput) error {
1162	if v == nil {
1163		return nil
1164	}
1165	invalidParams := smithy.InvalidParamsError{Context: "CreateEventBusInput"}
1166	if v.Name == nil {
1167		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1168	}
1169	if v.Tags != nil {
1170		if err := validateTagList(v.Tags); err != nil {
1171			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1172		}
1173	}
1174	if invalidParams.Len() > 0 {
1175		return invalidParams
1176	} else {
1177		return nil
1178	}
1179}
1180
1181func validateOpCreatePartnerEventSourceInput(v *CreatePartnerEventSourceInput) error {
1182	if v == nil {
1183		return nil
1184	}
1185	invalidParams := smithy.InvalidParamsError{Context: "CreatePartnerEventSourceInput"}
1186	if v.Name == nil {
1187		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1188	}
1189	if v.Account == nil {
1190		invalidParams.Add(smithy.NewErrParamRequired("Account"))
1191	}
1192	if invalidParams.Len() > 0 {
1193		return invalidParams
1194	} else {
1195		return nil
1196	}
1197}
1198
1199func validateOpDeactivateEventSourceInput(v *DeactivateEventSourceInput) error {
1200	if v == nil {
1201		return nil
1202	}
1203	invalidParams := smithy.InvalidParamsError{Context: "DeactivateEventSourceInput"}
1204	if v.Name == nil {
1205		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1206	}
1207	if invalidParams.Len() > 0 {
1208		return invalidParams
1209	} else {
1210		return nil
1211	}
1212}
1213
1214func validateOpDeleteArchiveInput(v *DeleteArchiveInput) error {
1215	if v == nil {
1216		return nil
1217	}
1218	invalidParams := smithy.InvalidParamsError{Context: "DeleteArchiveInput"}
1219	if v.ArchiveName == nil {
1220		invalidParams.Add(smithy.NewErrParamRequired("ArchiveName"))
1221	}
1222	if invalidParams.Len() > 0 {
1223		return invalidParams
1224	} else {
1225		return nil
1226	}
1227}
1228
1229func validateOpDeleteEventBusInput(v *DeleteEventBusInput) error {
1230	if v == nil {
1231		return nil
1232	}
1233	invalidParams := smithy.InvalidParamsError{Context: "DeleteEventBusInput"}
1234	if v.Name == nil {
1235		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1236	}
1237	if invalidParams.Len() > 0 {
1238		return invalidParams
1239	} else {
1240		return nil
1241	}
1242}
1243
1244func validateOpDeletePartnerEventSourceInput(v *DeletePartnerEventSourceInput) error {
1245	if v == nil {
1246		return nil
1247	}
1248	invalidParams := smithy.InvalidParamsError{Context: "DeletePartnerEventSourceInput"}
1249	if v.Name == nil {
1250		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1251	}
1252	if v.Account == nil {
1253		invalidParams.Add(smithy.NewErrParamRequired("Account"))
1254	}
1255	if invalidParams.Len() > 0 {
1256		return invalidParams
1257	} else {
1258		return nil
1259	}
1260}
1261
1262func validateOpDeleteRuleInput(v *DeleteRuleInput) error {
1263	if v == nil {
1264		return nil
1265	}
1266	invalidParams := smithy.InvalidParamsError{Context: "DeleteRuleInput"}
1267	if v.Name == nil {
1268		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1269	}
1270	if invalidParams.Len() > 0 {
1271		return invalidParams
1272	} else {
1273		return nil
1274	}
1275}
1276
1277func validateOpDescribeArchiveInput(v *DescribeArchiveInput) error {
1278	if v == nil {
1279		return nil
1280	}
1281	invalidParams := smithy.InvalidParamsError{Context: "DescribeArchiveInput"}
1282	if v.ArchiveName == nil {
1283		invalidParams.Add(smithy.NewErrParamRequired("ArchiveName"))
1284	}
1285	if invalidParams.Len() > 0 {
1286		return invalidParams
1287	} else {
1288		return nil
1289	}
1290}
1291
1292func validateOpDescribeEventSourceInput(v *DescribeEventSourceInput) error {
1293	if v == nil {
1294		return nil
1295	}
1296	invalidParams := smithy.InvalidParamsError{Context: "DescribeEventSourceInput"}
1297	if v.Name == nil {
1298		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1299	}
1300	if invalidParams.Len() > 0 {
1301		return invalidParams
1302	} else {
1303		return nil
1304	}
1305}
1306
1307func validateOpDescribePartnerEventSourceInput(v *DescribePartnerEventSourceInput) error {
1308	if v == nil {
1309		return nil
1310	}
1311	invalidParams := smithy.InvalidParamsError{Context: "DescribePartnerEventSourceInput"}
1312	if v.Name == nil {
1313		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1314	}
1315	if invalidParams.Len() > 0 {
1316		return invalidParams
1317	} else {
1318		return nil
1319	}
1320}
1321
1322func validateOpDescribeReplayInput(v *DescribeReplayInput) error {
1323	if v == nil {
1324		return nil
1325	}
1326	invalidParams := smithy.InvalidParamsError{Context: "DescribeReplayInput"}
1327	if v.ReplayName == nil {
1328		invalidParams.Add(smithy.NewErrParamRequired("ReplayName"))
1329	}
1330	if invalidParams.Len() > 0 {
1331		return invalidParams
1332	} else {
1333		return nil
1334	}
1335}
1336
1337func validateOpDescribeRuleInput(v *DescribeRuleInput) error {
1338	if v == nil {
1339		return nil
1340	}
1341	invalidParams := smithy.InvalidParamsError{Context: "DescribeRuleInput"}
1342	if v.Name == nil {
1343		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1344	}
1345	if invalidParams.Len() > 0 {
1346		return invalidParams
1347	} else {
1348		return nil
1349	}
1350}
1351
1352func validateOpDisableRuleInput(v *DisableRuleInput) error {
1353	if v == nil {
1354		return nil
1355	}
1356	invalidParams := smithy.InvalidParamsError{Context: "DisableRuleInput"}
1357	if v.Name == nil {
1358		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1359	}
1360	if invalidParams.Len() > 0 {
1361		return invalidParams
1362	} else {
1363		return nil
1364	}
1365}
1366
1367func validateOpEnableRuleInput(v *EnableRuleInput) error {
1368	if v == nil {
1369		return nil
1370	}
1371	invalidParams := smithy.InvalidParamsError{Context: "EnableRuleInput"}
1372	if v.Name == nil {
1373		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1374	}
1375	if invalidParams.Len() > 0 {
1376		return invalidParams
1377	} else {
1378		return nil
1379	}
1380}
1381
1382func validateOpListPartnerEventSourceAccountsInput(v *ListPartnerEventSourceAccountsInput) error {
1383	if v == nil {
1384		return nil
1385	}
1386	invalidParams := smithy.InvalidParamsError{Context: "ListPartnerEventSourceAccountsInput"}
1387	if v.EventSourceName == nil {
1388		invalidParams.Add(smithy.NewErrParamRequired("EventSourceName"))
1389	}
1390	if invalidParams.Len() > 0 {
1391		return invalidParams
1392	} else {
1393		return nil
1394	}
1395}
1396
1397func validateOpListPartnerEventSourcesInput(v *ListPartnerEventSourcesInput) error {
1398	if v == nil {
1399		return nil
1400	}
1401	invalidParams := smithy.InvalidParamsError{Context: "ListPartnerEventSourcesInput"}
1402	if v.NamePrefix == nil {
1403		invalidParams.Add(smithy.NewErrParamRequired("NamePrefix"))
1404	}
1405	if invalidParams.Len() > 0 {
1406		return invalidParams
1407	} else {
1408		return nil
1409	}
1410}
1411
1412func validateOpListRuleNamesByTargetInput(v *ListRuleNamesByTargetInput) error {
1413	if v == nil {
1414		return nil
1415	}
1416	invalidParams := smithy.InvalidParamsError{Context: "ListRuleNamesByTargetInput"}
1417	if v.TargetArn == nil {
1418		invalidParams.Add(smithy.NewErrParamRequired("TargetArn"))
1419	}
1420	if invalidParams.Len() > 0 {
1421		return invalidParams
1422	} else {
1423		return nil
1424	}
1425}
1426
1427func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1428	if v == nil {
1429		return nil
1430	}
1431	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1432	if v.ResourceARN == nil {
1433		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
1434	}
1435	if invalidParams.Len() > 0 {
1436		return invalidParams
1437	} else {
1438		return nil
1439	}
1440}
1441
1442func validateOpListTargetsByRuleInput(v *ListTargetsByRuleInput) error {
1443	if v == nil {
1444		return nil
1445	}
1446	invalidParams := smithy.InvalidParamsError{Context: "ListTargetsByRuleInput"}
1447	if v.Rule == nil {
1448		invalidParams.Add(smithy.NewErrParamRequired("Rule"))
1449	}
1450	if invalidParams.Len() > 0 {
1451		return invalidParams
1452	} else {
1453		return nil
1454	}
1455}
1456
1457func validateOpPutEventsInput(v *PutEventsInput) error {
1458	if v == nil {
1459		return nil
1460	}
1461	invalidParams := smithy.InvalidParamsError{Context: "PutEventsInput"}
1462	if v.Entries == nil {
1463		invalidParams.Add(smithy.NewErrParamRequired("Entries"))
1464	}
1465	if invalidParams.Len() > 0 {
1466		return invalidParams
1467	} else {
1468		return nil
1469	}
1470}
1471
1472func validateOpPutPartnerEventsInput(v *PutPartnerEventsInput) error {
1473	if v == nil {
1474		return nil
1475	}
1476	invalidParams := smithy.InvalidParamsError{Context: "PutPartnerEventsInput"}
1477	if v.Entries == nil {
1478		invalidParams.Add(smithy.NewErrParamRequired("Entries"))
1479	}
1480	if invalidParams.Len() > 0 {
1481		return invalidParams
1482	} else {
1483		return nil
1484	}
1485}
1486
1487func validateOpPutPermissionInput(v *PutPermissionInput) error {
1488	if v == nil {
1489		return nil
1490	}
1491	invalidParams := smithy.InvalidParamsError{Context: "PutPermissionInput"}
1492	if v.Condition != nil {
1493		if err := validateCondition(v.Condition); err != nil {
1494			invalidParams.AddNested("Condition", err.(smithy.InvalidParamsError))
1495		}
1496	}
1497	if invalidParams.Len() > 0 {
1498		return invalidParams
1499	} else {
1500		return nil
1501	}
1502}
1503
1504func validateOpPutRuleInput(v *PutRuleInput) error {
1505	if v == nil {
1506		return nil
1507	}
1508	invalidParams := smithy.InvalidParamsError{Context: "PutRuleInput"}
1509	if v.Name == nil {
1510		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1511	}
1512	if v.Tags != nil {
1513		if err := validateTagList(v.Tags); err != nil {
1514			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1515		}
1516	}
1517	if invalidParams.Len() > 0 {
1518		return invalidParams
1519	} else {
1520		return nil
1521	}
1522}
1523
1524func validateOpPutTargetsInput(v *PutTargetsInput) error {
1525	if v == nil {
1526		return nil
1527	}
1528	invalidParams := smithy.InvalidParamsError{Context: "PutTargetsInput"}
1529	if v.Rule == nil {
1530		invalidParams.Add(smithy.NewErrParamRequired("Rule"))
1531	}
1532	if v.Targets == nil {
1533		invalidParams.Add(smithy.NewErrParamRequired("Targets"))
1534	} else if v.Targets != nil {
1535		if err := validateTargetList(v.Targets); err != nil {
1536			invalidParams.AddNested("Targets", err.(smithy.InvalidParamsError))
1537		}
1538	}
1539	if invalidParams.Len() > 0 {
1540		return invalidParams
1541	} else {
1542		return nil
1543	}
1544}
1545
1546func validateOpRemoveTargetsInput(v *RemoveTargetsInput) error {
1547	if v == nil {
1548		return nil
1549	}
1550	invalidParams := smithy.InvalidParamsError{Context: "RemoveTargetsInput"}
1551	if v.Rule == nil {
1552		invalidParams.Add(smithy.NewErrParamRequired("Rule"))
1553	}
1554	if v.Ids == nil {
1555		invalidParams.Add(smithy.NewErrParamRequired("Ids"))
1556	}
1557	if invalidParams.Len() > 0 {
1558		return invalidParams
1559	} else {
1560		return nil
1561	}
1562}
1563
1564func validateOpStartReplayInput(v *StartReplayInput) error {
1565	if v == nil {
1566		return nil
1567	}
1568	invalidParams := smithy.InvalidParamsError{Context: "StartReplayInput"}
1569	if v.ReplayName == nil {
1570		invalidParams.Add(smithy.NewErrParamRequired("ReplayName"))
1571	}
1572	if v.EventSourceArn == nil {
1573		invalidParams.Add(smithy.NewErrParamRequired("EventSourceArn"))
1574	}
1575	if v.EventStartTime == nil {
1576		invalidParams.Add(smithy.NewErrParamRequired("EventStartTime"))
1577	}
1578	if v.EventEndTime == nil {
1579		invalidParams.Add(smithy.NewErrParamRequired("EventEndTime"))
1580	}
1581	if v.Destination == nil {
1582		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
1583	} else if v.Destination != nil {
1584		if err := validateReplayDestination(v.Destination); err != nil {
1585			invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError))
1586		}
1587	}
1588	if invalidParams.Len() > 0 {
1589		return invalidParams
1590	} else {
1591		return nil
1592	}
1593}
1594
1595func validateOpTagResourceInput(v *TagResourceInput) error {
1596	if v == nil {
1597		return nil
1598	}
1599	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
1600	if v.ResourceARN == nil {
1601		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
1602	}
1603	if v.Tags == nil {
1604		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1605	} else if v.Tags != nil {
1606		if err := validateTagList(v.Tags); err != nil {
1607			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
1608		}
1609	}
1610	if invalidParams.Len() > 0 {
1611		return invalidParams
1612	} else {
1613		return nil
1614	}
1615}
1616
1617func validateOpTestEventPatternInput(v *TestEventPatternInput) error {
1618	if v == nil {
1619		return nil
1620	}
1621	invalidParams := smithy.InvalidParamsError{Context: "TestEventPatternInput"}
1622	if v.EventPattern == nil {
1623		invalidParams.Add(smithy.NewErrParamRequired("EventPattern"))
1624	}
1625	if v.Event == nil {
1626		invalidParams.Add(smithy.NewErrParamRequired("Event"))
1627	}
1628	if invalidParams.Len() > 0 {
1629		return invalidParams
1630	} else {
1631		return nil
1632	}
1633}
1634
1635func validateOpUntagResourceInput(v *UntagResourceInput) error {
1636	if v == nil {
1637		return nil
1638	}
1639	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
1640	if v.ResourceARN == nil {
1641		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
1642	}
1643	if v.TagKeys == nil {
1644		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
1645	}
1646	if invalidParams.Len() > 0 {
1647		return invalidParams
1648	} else {
1649		return nil
1650	}
1651}
1652
1653func validateOpUpdateArchiveInput(v *UpdateArchiveInput) error {
1654	if v == nil {
1655		return nil
1656	}
1657	invalidParams := smithy.InvalidParamsError{Context: "UpdateArchiveInput"}
1658	if v.ArchiveName == nil {
1659		invalidParams.Add(smithy.NewErrParamRequired("ArchiveName"))
1660	}
1661	if invalidParams.Len() > 0 {
1662		return invalidParams
1663	} else {
1664		return nil
1665	}
1666}
1667