1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package redshift
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/redshift/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAcceptReservedNodeExchange struct {
14}
15
16func (*validateOpAcceptReservedNodeExchange) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAcceptReservedNodeExchange) 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.(*AcceptReservedNodeExchangeInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAcceptReservedNodeExchangeInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpAuthorizeClusterSecurityGroupIngress struct {
34}
35
36func (*validateOpAuthorizeClusterSecurityGroupIngress) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpAuthorizeClusterSecurityGroupIngress) 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.(*AuthorizeClusterSecurityGroupIngressInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpAuthorizeClusterSecurityGroupIngressInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpAuthorizeSnapshotAccess struct {
54}
55
56func (*validateOpAuthorizeSnapshotAccess) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpAuthorizeSnapshotAccess) 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.(*AuthorizeSnapshotAccessInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpAuthorizeSnapshotAccessInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpBatchDeleteClusterSnapshots struct {
74}
75
76func (*validateOpBatchDeleteClusterSnapshots) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpBatchDeleteClusterSnapshots) 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.(*BatchDeleteClusterSnapshotsInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpBatchDeleteClusterSnapshotsInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpBatchModifyClusterSnapshots struct {
94}
95
96func (*validateOpBatchModifyClusterSnapshots) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpBatchModifyClusterSnapshots) 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.(*BatchModifyClusterSnapshotsInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpBatchModifyClusterSnapshotsInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCancelResize struct {
114}
115
116func (*validateOpCancelResize) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCancelResize) 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.(*CancelResizeInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCancelResizeInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpCopyClusterSnapshot struct {
134}
135
136func (*validateOpCopyClusterSnapshot) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpCopyClusterSnapshot) 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.(*CopyClusterSnapshotInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpCopyClusterSnapshotInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpCreateCluster struct {
154}
155
156func (*validateOpCreateCluster) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpCreateCluster) 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.(*CreateClusterInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpCreateClusterInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpCreateClusterParameterGroup struct {
174}
175
176func (*validateOpCreateClusterParameterGroup) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpCreateClusterParameterGroup) 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.(*CreateClusterParameterGroupInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpCreateClusterParameterGroupInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpCreateClusterSecurityGroup struct {
194}
195
196func (*validateOpCreateClusterSecurityGroup) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpCreateClusterSecurityGroup) 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.(*CreateClusterSecurityGroupInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpCreateClusterSecurityGroupInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpCreateClusterSnapshot struct {
214}
215
216func (*validateOpCreateClusterSnapshot) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpCreateClusterSnapshot) 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.(*CreateClusterSnapshotInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpCreateClusterSnapshotInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpCreateClusterSubnetGroup struct {
234}
235
236func (*validateOpCreateClusterSubnetGroup) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpCreateClusterSubnetGroup) 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.(*CreateClusterSubnetGroupInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpCreateClusterSubnetGroupInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpCreateEventSubscription struct {
254}
255
256func (*validateOpCreateEventSubscription) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpCreateEventSubscription) 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.(*CreateEventSubscriptionInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpCreateEventSubscriptionInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpCreateHsmClientCertificate struct {
274}
275
276func (*validateOpCreateHsmClientCertificate) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpCreateHsmClientCertificate) 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.(*CreateHsmClientCertificateInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpCreateHsmClientCertificateInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpCreateHsmConfiguration struct {
294}
295
296func (*validateOpCreateHsmConfiguration) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpCreateHsmConfiguration) 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.(*CreateHsmConfigurationInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpCreateHsmConfigurationInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpCreateScheduledAction struct {
314}
315
316func (*validateOpCreateScheduledAction) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpCreateScheduledAction) 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.(*CreateScheduledActionInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpCreateScheduledActionInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpCreateSnapshotCopyGrant struct {
334}
335
336func (*validateOpCreateSnapshotCopyGrant) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpCreateSnapshotCopyGrant) 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.(*CreateSnapshotCopyGrantInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpCreateSnapshotCopyGrantInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpCreateTags struct {
354}
355
356func (*validateOpCreateTags) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpCreateTags) 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.(*CreateTagsInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpCreateTagsInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpCreateUsageLimit struct {
374}
375
376func (*validateOpCreateUsageLimit) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpCreateUsageLimit) 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.(*CreateUsageLimitInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpCreateUsageLimitInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDeleteCluster struct {
394}
395
396func (*validateOpDeleteCluster) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDeleteCluster) 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.(*DeleteClusterInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDeleteClusterInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDeleteClusterParameterGroup struct {
414}
415
416func (*validateOpDeleteClusterParameterGroup) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDeleteClusterParameterGroup) 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.(*DeleteClusterParameterGroupInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDeleteClusterParameterGroupInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpDeleteClusterSecurityGroup struct {
434}
435
436func (*validateOpDeleteClusterSecurityGroup) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpDeleteClusterSecurityGroup) 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.(*DeleteClusterSecurityGroupInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpDeleteClusterSecurityGroupInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpDeleteClusterSnapshot struct {
454}
455
456func (*validateOpDeleteClusterSnapshot) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpDeleteClusterSnapshot) 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.(*DeleteClusterSnapshotInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpDeleteClusterSnapshotInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpDeleteClusterSubnetGroup struct {
474}
475
476func (*validateOpDeleteClusterSubnetGroup) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpDeleteClusterSubnetGroup) 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.(*DeleteClusterSubnetGroupInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpDeleteClusterSubnetGroupInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpDeleteEventSubscription struct {
494}
495
496func (*validateOpDeleteEventSubscription) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpDeleteEventSubscription) 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.(*DeleteEventSubscriptionInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpDeleteEventSubscriptionInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpDeleteHsmClientCertificate struct {
514}
515
516func (*validateOpDeleteHsmClientCertificate) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpDeleteHsmClientCertificate) 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.(*DeleteHsmClientCertificateInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpDeleteHsmClientCertificateInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpDeleteHsmConfiguration struct {
534}
535
536func (*validateOpDeleteHsmConfiguration) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpDeleteHsmConfiguration) 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.(*DeleteHsmConfigurationInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpDeleteHsmConfigurationInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpDeleteScheduledAction struct {
554}
555
556func (*validateOpDeleteScheduledAction) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpDeleteScheduledAction) 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.(*DeleteScheduledActionInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpDeleteScheduledActionInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpDeleteSnapshotCopyGrant struct {
574}
575
576func (*validateOpDeleteSnapshotCopyGrant) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpDeleteSnapshotCopyGrant) 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.(*DeleteSnapshotCopyGrantInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpDeleteSnapshotCopyGrantInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpDeleteSnapshotSchedule struct {
594}
595
596func (*validateOpDeleteSnapshotSchedule) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpDeleteSnapshotSchedule) 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.(*DeleteSnapshotScheduleInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpDeleteSnapshotScheduleInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpDeleteTags struct {
614}
615
616func (*validateOpDeleteTags) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpDeleteTags) 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.(*DeleteTagsInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpDeleteTagsInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpDeleteUsageLimit struct {
634}
635
636func (*validateOpDeleteUsageLimit) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpDeleteUsageLimit) 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.(*DeleteUsageLimitInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpDeleteUsageLimitInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpDescribeClusterParameters struct {
654}
655
656func (*validateOpDescribeClusterParameters) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpDescribeClusterParameters) 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.(*DescribeClusterParametersInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpDescribeClusterParametersInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpDescribeClusterSnapshots struct {
674}
675
676func (*validateOpDescribeClusterSnapshots) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpDescribeClusterSnapshots) 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.(*DescribeClusterSnapshotsInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpDescribeClusterSnapshotsInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpDescribeDefaultClusterParameters struct {
694}
695
696func (*validateOpDescribeDefaultClusterParameters) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpDescribeDefaultClusterParameters) 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.(*DescribeDefaultClusterParametersInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpDescribeDefaultClusterParametersInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpDescribeLoggingStatus struct {
714}
715
716func (*validateOpDescribeLoggingStatus) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpDescribeLoggingStatus) 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.(*DescribeLoggingStatusInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpDescribeLoggingStatusInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpDescribeNodeConfigurationOptions struct {
734}
735
736func (*validateOpDescribeNodeConfigurationOptions) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpDescribeNodeConfigurationOptions) 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.(*DescribeNodeConfigurationOptionsInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpDescribeNodeConfigurationOptionsInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpDescribeResize struct {
754}
755
756func (*validateOpDescribeResize) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpDescribeResize) 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.(*DescribeResizeInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpDescribeResizeInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpDescribeScheduledActions struct {
774}
775
776func (*validateOpDescribeScheduledActions) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpDescribeScheduledActions) 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.(*DescribeScheduledActionsInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpDescribeScheduledActionsInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpDisableLogging struct {
794}
795
796func (*validateOpDisableLogging) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpDisableLogging) 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.(*DisableLoggingInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpDisableLoggingInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpDisableSnapshotCopy struct {
814}
815
816func (*validateOpDisableSnapshotCopy) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpDisableSnapshotCopy) 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.(*DisableSnapshotCopyInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpDisableSnapshotCopyInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpEnableLogging struct {
834}
835
836func (*validateOpEnableLogging) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpEnableLogging) 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.(*EnableLoggingInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpEnableLoggingInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpEnableSnapshotCopy struct {
854}
855
856func (*validateOpEnableSnapshotCopy) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpEnableSnapshotCopy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
861	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
862) {
863	input, ok := in.Parameters.(*EnableSnapshotCopyInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpEnableSnapshotCopyInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpGetClusterCredentials struct {
874}
875
876func (*validateOpGetClusterCredentials) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpGetClusterCredentials) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
881	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
882) {
883	input, ok := in.Parameters.(*GetClusterCredentialsInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpGetClusterCredentialsInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893type validateOpGetReservedNodeExchangeOfferings struct {
894}
895
896func (*validateOpGetReservedNodeExchangeOfferings) ID() string {
897	return "OperationInputValidation"
898}
899
900func (m *validateOpGetReservedNodeExchangeOfferings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
901	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
902) {
903	input, ok := in.Parameters.(*GetReservedNodeExchangeOfferingsInput)
904	if !ok {
905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
906	}
907	if err := validateOpGetReservedNodeExchangeOfferingsInput(input); err != nil {
908		return out, metadata, err
909	}
910	return next.HandleInitialize(ctx, in)
911}
912
913type validateOpModifyClusterDbRevision struct {
914}
915
916func (*validateOpModifyClusterDbRevision) ID() string {
917	return "OperationInputValidation"
918}
919
920func (m *validateOpModifyClusterDbRevision) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
921	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
922) {
923	input, ok := in.Parameters.(*ModifyClusterDbRevisionInput)
924	if !ok {
925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
926	}
927	if err := validateOpModifyClusterDbRevisionInput(input); err != nil {
928		return out, metadata, err
929	}
930	return next.HandleInitialize(ctx, in)
931}
932
933type validateOpModifyClusterIamRoles struct {
934}
935
936func (*validateOpModifyClusterIamRoles) ID() string {
937	return "OperationInputValidation"
938}
939
940func (m *validateOpModifyClusterIamRoles) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
941	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
942) {
943	input, ok := in.Parameters.(*ModifyClusterIamRolesInput)
944	if !ok {
945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
946	}
947	if err := validateOpModifyClusterIamRolesInput(input); err != nil {
948		return out, metadata, err
949	}
950	return next.HandleInitialize(ctx, in)
951}
952
953type validateOpModifyCluster struct {
954}
955
956func (*validateOpModifyCluster) ID() string {
957	return "OperationInputValidation"
958}
959
960func (m *validateOpModifyCluster) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
961	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
962) {
963	input, ok := in.Parameters.(*ModifyClusterInput)
964	if !ok {
965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
966	}
967	if err := validateOpModifyClusterInput(input); err != nil {
968		return out, metadata, err
969	}
970	return next.HandleInitialize(ctx, in)
971}
972
973type validateOpModifyClusterMaintenance struct {
974}
975
976func (*validateOpModifyClusterMaintenance) ID() string {
977	return "OperationInputValidation"
978}
979
980func (m *validateOpModifyClusterMaintenance) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
981	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
982) {
983	input, ok := in.Parameters.(*ModifyClusterMaintenanceInput)
984	if !ok {
985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
986	}
987	if err := validateOpModifyClusterMaintenanceInput(input); err != nil {
988		return out, metadata, err
989	}
990	return next.HandleInitialize(ctx, in)
991}
992
993type validateOpModifyClusterParameterGroup struct {
994}
995
996func (*validateOpModifyClusterParameterGroup) ID() string {
997	return "OperationInputValidation"
998}
999
1000func (m *validateOpModifyClusterParameterGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1001	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1002) {
1003	input, ok := in.Parameters.(*ModifyClusterParameterGroupInput)
1004	if !ok {
1005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1006	}
1007	if err := validateOpModifyClusterParameterGroupInput(input); err != nil {
1008		return out, metadata, err
1009	}
1010	return next.HandleInitialize(ctx, in)
1011}
1012
1013type validateOpModifyClusterSnapshot struct {
1014}
1015
1016func (*validateOpModifyClusterSnapshot) ID() string {
1017	return "OperationInputValidation"
1018}
1019
1020func (m *validateOpModifyClusterSnapshot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1021	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1022) {
1023	input, ok := in.Parameters.(*ModifyClusterSnapshotInput)
1024	if !ok {
1025		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1026	}
1027	if err := validateOpModifyClusterSnapshotInput(input); err != nil {
1028		return out, metadata, err
1029	}
1030	return next.HandleInitialize(ctx, in)
1031}
1032
1033type validateOpModifyClusterSnapshotSchedule struct {
1034}
1035
1036func (*validateOpModifyClusterSnapshotSchedule) ID() string {
1037	return "OperationInputValidation"
1038}
1039
1040func (m *validateOpModifyClusterSnapshotSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1041	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1042) {
1043	input, ok := in.Parameters.(*ModifyClusterSnapshotScheduleInput)
1044	if !ok {
1045		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1046	}
1047	if err := validateOpModifyClusterSnapshotScheduleInput(input); err != nil {
1048		return out, metadata, err
1049	}
1050	return next.HandleInitialize(ctx, in)
1051}
1052
1053type validateOpModifyClusterSubnetGroup struct {
1054}
1055
1056func (*validateOpModifyClusterSubnetGroup) ID() string {
1057	return "OperationInputValidation"
1058}
1059
1060func (m *validateOpModifyClusterSubnetGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1061	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1062) {
1063	input, ok := in.Parameters.(*ModifyClusterSubnetGroupInput)
1064	if !ok {
1065		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1066	}
1067	if err := validateOpModifyClusterSubnetGroupInput(input); err != nil {
1068		return out, metadata, err
1069	}
1070	return next.HandleInitialize(ctx, in)
1071}
1072
1073type validateOpModifyEventSubscription struct {
1074}
1075
1076func (*validateOpModifyEventSubscription) ID() string {
1077	return "OperationInputValidation"
1078}
1079
1080func (m *validateOpModifyEventSubscription) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1081	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1082) {
1083	input, ok := in.Parameters.(*ModifyEventSubscriptionInput)
1084	if !ok {
1085		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1086	}
1087	if err := validateOpModifyEventSubscriptionInput(input); err != nil {
1088		return out, metadata, err
1089	}
1090	return next.HandleInitialize(ctx, in)
1091}
1092
1093type validateOpModifyScheduledAction struct {
1094}
1095
1096func (*validateOpModifyScheduledAction) ID() string {
1097	return "OperationInputValidation"
1098}
1099
1100func (m *validateOpModifyScheduledAction) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1101	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1102) {
1103	input, ok := in.Parameters.(*ModifyScheduledActionInput)
1104	if !ok {
1105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1106	}
1107	if err := validateOpModifyScheduledActionInput(input); err != nil {
1108		return out, metadata, err
1109	}
1110	return next.HandleInitialize(ctx, in)
1111}
1112
1113type validateOpModifySnapshotCopyRetentionPeriod struct {
1114}
1115
1116func (*validateOpModifySnapshotCopyRetentionPeriod) ID() string {
1117	return "OperationInputValidation"
1118}
1119
1120func (m *validateOpModifySnapshotCopyRetentionPeriod) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1121	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1122) {
1123	input, ok := in.Parameters.(*ModifySnapshotCopyRetentionPeriodInput)
1124	if !ok {
1125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1126	}
1127	if err := validateOpModifySnapshotCopyRetentionPeriodInput(input); err != nil {
1128		return out, metadata, err
1129	}
1130	return next.HandleInitialize(ctx, in)
1131}
1132
1133type validateOpModifySnapshotSchedule struct {
1134}
1135
1136func (*validateOpModifySnapshotSchedule) ID() string {
1137	return "OperationInputValidation"
1138}
1139
1140func (m *validateOpModifySnapshotSchedule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1141	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1142) {
1143	input, ok := in.Parameters.(*ModifySnapshotScheduleInput)
1144	if !ok {
1145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1146	}
1147	if err := validateOpModifySnapshotScheduleInput(input); err != nil {
1148		return out, metadata, err
1149	}
1150	return next.HandleInitialize(ctx, in)
1151}
1152
1153type validateOpModifyUsageLimit struct {
1154}
1155
1156func (*validateOpModifyUsageLimit) ID() string {
1157	return "OperationInputValidation"
1158}
1159
1160func (m *validateOpModifyUsageLimit) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1161	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1162) {
1163	input, ok := in.Parameters.(*ModifyUsageLimitInput)
1164	if !ok {
1165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1166	}
1167	if err := validateOpModifyUsageLimitInput(input); err != nil {
1168		return out, metadata, err
1169	}
1170	return next.HandleInitialize(ctx, in)
1171}
1172
1173type validateOpPauseCluster struct {
1174}
1175
1176func (*validateOpPauseCluster) ID() string {
1177	return "OperationInputValidation"
1178}
1179
1180func (m *validateOpPauseCluster) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1181	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1182) {
1183	input, ok := in.Parameters.(*PauseClusterInput)
1184	if !ok {
1185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1186	}
1187	if err := validateOpPauseClusterInput(input); err != nil {
1188		return out, metadata, err
1189	}
1190	return next.HandleInitialize(ctx, in)
1191}
1192
1193type validateOpPurchaseReservedNodeOffering struct {
1194}
1195
1196func (*validateOpPurchaseReservedNodeOffering) ID() string {
1197	return "OperationInputValidation"
1198}
1199
1200func (m *validateOpPurchaseReservedNodeOffering) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1201	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1202) {
1203	input, ok := in.Parameters.(*PurchaseReservedNodeOfferingInput)
1204	if !ok {
1205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1206	}
1207	if err := validateOpPurchaseReservedNodeOfferingInput(input); err != nil {
1208		return out, metadata, err
1209	}
1210	return next.HandleInitialize(ctx, in)
1211}
1212
1213type validateOpRebootCluster struct {
1214}
1215
1216func (*validateOpRebootCluster) ID() string {
1217	return "OperationInputValidation"
1218}
1219
1220func (m *validateOpRebootCluster) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1221	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1222) {
1223	input, ok := in.Parameters.(*RebootClusterInput)
1224	if !ok {
1225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1226	}
1227	if err := validateOpRebootClusterInput(input); err != nil {
1228		return out, metadata, err
1229	}
1230	return next.HandleInitialize(ctx, in)
1231}
1232
1233type validateOpResetClusterParameterGroup struct {
1234}
1235
1236func (*validateOpResetClusterParameterGroup) ID() string {
1237	return "OperationInputValidation"
1238}
1239
1240func (m *validateOpResetClusterParameterGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1241	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1242) {
1243	input, ok := in.Parameters.(*ResetClusterParameterGroupInput)
1244	if !ok {
1245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1246	}
1247	if err := validateOpResetClusterParameterGroupInput(input); err != nil {
1248		return out, metadata, err
1249	}
1250	return next.HandleInitialize(ctx, in)
1251}
1252
1253type validateOpResizeCluster struct {
1254}
1255
1256func (*validateOpResizeCluster) ID() string {
1257	return "OperationInputValidation"
1258}
1259
1260func (m *validateOpResizeCluster) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1261	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1262) {
1263	input, ok := in.Parameters.(*ResizeClusterInput)
1264	if !ok {
1265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1266	}
1267	if err := validateOpResizeClusterInput(input); err != nil {
1268		return out, metadata, err
1269	}
1270	return next.HandleInitialize(ctx, in)
1271}
1272
1273type validateOpRestoreFromClusterSnapshot struct {
1274}
1275
1276func (*validateOpRestoreFromClusterSnapshot) ID() string {
1277	return "OperationInputValidation"
1278}
1279
1280func (m *validateOpRestoreFromClusterSnapshot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1281	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1282) {
1283	input, ok := in.Parameters.(*RestoreFromClusterSnapshotInput)
1284	if !ok {
1285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1286	}
1287	if err := validateOpRestoreFromClusterSnapshotInput(input); err != nil {
1288		return out, metadata, err
1289	}
1290	return next.HandleInitialize(ctx, in)
1291}
1292
1293type validateOpRestoreTableFromClusterSnapshot struct {
1294}
1295
1296func (*validateOpRestoreTableFromClusterSnapshot) ID() string {
1297	return "OperationInputValidation"
1298}
1299
1300func (m *validateOpRestoreTableFromClusterSnapshot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1301	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1302) {
1303	input, ok := in.Parameters.(*RestoreTableFromClusterSnapshotInput)
1304	if !ok {
1305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1306	}
1307	if err := validateOpRestoreTableFromClusterSnapshotInput(input); err != nil {
1308		return out, metadata, err
1309	}
1310	return next.HandleInitialize(ctx, in)
1311}
1312
1313type validateOpResumeCluster struct {
1314}
1315
1316func (*validateOpResumeCluster) ID() string {
1317	return "OperationInputValidation"
1318}
1319
1320func (m *validateOpResumeCluster) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1321	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1322) {
1323	input, ok := in.Parameters.(*ResumeClusterInput)
1324	if !ok {
1325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1326	}
1327	if err := validateOpResumeClusterInput(input); err != nil {
1328		return out, metadata, err
1329	}
1330	return next.HandleInitialize(ctx, in)
1331}
1332
1333type validateOpRevokeClusterSecurityGroupIngress struct {
1334}
1335
1336func (*validateOpRevokeClusterSecurityGroupIngress) ID() string {
1337	return "OperationInputValidation"
1338}
1339
1340func (m *validateOpRevokeClusterSecurityGroupIngress) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1341	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1342) {
1343	input, ok := in.Parameters.(*RevokeClusterSecurityGroupIngressInput)
1344	if !ok {
1345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1346	}
1347	if err := validateOpRevokeClusterSecurityGroupIngressInput(input); err != nil {
1348		return out, metadata, err
1349	}
1350	return next.HandleInitialize(ctx, in)
1351}
1352
1353type validateOpRevokeSnapshotAccess struct {
1354}
1355
1356func (*validateOpRevokeSnapshotAccess) ID() string {
1357	return "OperationInputValidation"
1358}
1359
1360func (m *validateOpRevokeSnapshotAccess) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1361	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1362) {
1363	input, ok := in.Parameters.(*RevokeSnapshotAccessInput)
1364	if !ok {
1365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1366	}
1367	if err := validateOpRevokeSnapshotAccessInput(input); err != nil {
1368		return out, metadata, err
1369	}
1370	return next.HandleInitialize(ctx, in)
1371}
1372
1373type validateOpRotateEncryptionKey struct {
1374}
1375
1376func (*validateOpRotateEncryptionKey) ID() string {
1377	return "OperationInputValidation"
1378}
1379
1380func (m *validateOpRotateEncryptionKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
1381	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
1382) {
1383	input, ok := in.Parameters.(*RotateEncryptionKeyInput)
1384	if !ok {
1385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1386	}
1387	if err := validateOpRotateEncryptionKeyInput(input); err != nil {
1388		return out, metadata, err
1389	}
1390	return next.HandleInitialize(ctx, in)
1391}
1392
1393func addOpAcceptReservedNodeExchangeValidationMiddleware(stack *middleware.Stack) error {
1394	return stack.Initialize.Add(&validateOpAcceptReservedNodeExchange{}, middleware.After)
1395}
1396
1397func addOpAuthorizeClusterSecurityGroupIngressValidationMiddleware(stack *middleware.Stack) error {
1398	return stack.Initialize.Add(&validateOpAuthorizeClusterSecurityGroupIngress{}, middleware.After)
1399}
1400
1401func addOpAuthorizeSnapshotAccessValidationMiddleware(stack *middleware.Stack) error {
1402	return stack.Initialize.Add(&validateOpAuthorizeSnapshotAccess{}, middleware.After)
1403}
1404
1405func addOpBatchDeleteClusterSnapshotsValidationMiddleware(stack *middleware.Stack) error {
1406	return stack.Initialize.Add(&validateOpBatchDeleteClusterSnapshots{}, middleware.After)
1407}
1408
1409func addOpBatchModifyClusterSnapshotsValidationMiddleware(stack *middleware.Stack) error {
1410	return stack.Initialize.Add(&validateOpBatchModifyClusterSnapshots{}, middleware.After)
1411}
1412
1413func addOpCancelResizeValidationMiddleware(stack *middleware.Stack) error {
1414	return stack.Initialize.Add(&validateOpCancelResize{}, middleware.After)
1415}
1416
1417func addOpCopyClusterSnapshotValidationMiddleware(stack *middleware.Stack) error {
1418	return stack.Initialize.Add(&validateOpCopyClusterSnapshot{}, middleware.After)
1419}
1420
1421func addOpCreateClusterValidationMiddleware(stack *middleware.Stack) error {
1422	return stack.Initialize.Add(&validateOpCreateCluster{}, middleware.After)
1423}
1424
1425func addOpCreateClusterParameterGroupValidationMiddleware(stack *middleware.Stack) error {
1426	return stack.Initialize.Add(&validateOpCreateClusterParameterGroup{}, middleware.After)
1427}
1428
1429func addOpCreateClusterSecurityGroupValidationMiddleware(stack *middleware.Stack) error {
1430	return stack.Initialize.Add(&validateOpCreateClusterSecurityGroup{}, middleware.After)
1431}
1432
1433func addOpCreateClusterSnapshotValidationMiddleware(stack *middleware.Stack) error {
1434	return stack.Initialize.Add(&validateOpCreateClusterSnapshot{}, middleware.After)
1435}
1436
1437func addOpCreateClusterSubnetGroupValidationMiddleware(stack *middleware.Stack) error {
1438	return stack.Initialize.Add(&validateOpCreateClusterSubnetGroup{}, middleware.After)
1439}
1440
1441func addOpCreateEventSubscriptionValidationMiddleware(stack *middleware.Stack) error {
1442	return stack.Initialize.Add(&validateOpCreateEventSubscription{}, middleware.After)
1443}
1444
1445func addOpCreateHsmClientCertificateValidationMiddleware(stack *middleware.Stack) error {
1446	return stack.Initialize.Add(&validateOpCreateHsmClientCertificate{}, middleware.After)
1447}
1448
1449func addOpCreateHsmConfigurationValidationMiddleware(stack *middleware.Stack) error {
1450	return stack.Initialize.Add(&validateOpCreateHsmConfiguration{}, middleware.After)
1451}
1452
1453func addOpCreateScheduledActionValidationMiddleware(stack *middleware.Stack) error {
1454	return stack.Initialize.Add(&validateOpCreateScheduledAction{}, middleware.After)
1455}
1456
1457func addOpCreateSnapshotCopyGrantValidationMiddleware(stack *middleware.Stack) error {
1458	return stack.Initialize.Add(&validateOpCreateSnapshotCopyGrant{}, middleware.After)
1459}
1460
1461func addOpCreateTagsValidationMiddleware(stack *middleware.Stack) error {
1462	return stack.Initialize.Add(&validateOpCreateTags{}, middleware.After)
1463}
1464
1465func addOpCreateUsageLimitValidationMiddleware(stack *middleware.Stack) error {
1466	return stack.Initialize.Add(&validateOpCreateUsageLimit{}, middleware.After)
1467}
1468
1469func addOpDeleteClusterValidationMiddleware(stack *middleware.Stack) error {
1470	return stack.Initialize.Add(&validateOpDeleteCluster{}, middleware.After)
1471}
1472
1473func addOpDeleteClusterParameterGroupValidationMiddleware(stack *middleware.Stack) error {
1474	return stack.Initialize.Add(&validateOpDeleteClusterParameterGroup{}, middleware.After)
1475}
1476
1477func addOpDeleteClusterSecurityGroupValidationMiddleware(stack *middleware.Stack) error {
1478	return stack.Initialize.Add(&validateOpDeleteClusterSecurityGroup{}, middleware.After)
1479}
1480
1481func addOpDeleteClusterSnapshotValidationMiddleware(stack *middleware.Stack) error {
1482	return stack.Initialize.Add(&validateOpDeleteClusterSnapshot{}, middleware.After)
1483}
1484
1485func addOpDeleteClusterSubnetGroupValidationMiddleware(stack *middleware.Stack) error {
1486	return stack.Initialize.Add(&validateOpDeleteClusterSubnetGroup{}, middleware.After)
1487}
1488
1489func addOpDeleteEventSubscriptionValidationMiddleware(stack *middleware.Stack) error {
1490	return stack.Initialize.Add(&validateOpDeleteEventSubscription{}, middleware.After)
1491}
1492
1493func addOpDeleteHsmClientCertificateValidationMiddleware(stack *middleware.Stack) error {
1494	return stack.Initialize.Add(&validateOpDeleteHsmClientCertificate{}, middleware.After)
1495}
1496
1497func addOpDeleteHsmConfigurationValidationMiddleware(stack *middleware.Stack) error {
1498	return stack.Initialize.Add(&validateOpDeleteHsmConfiguration{}, middleware.After)
1499}
1500
1501func addOpDeleteScheduledActionValidationMiddleware(stack *middleware.Stack) error {
1502	return stack.Initialize.Add(&validateOpDeleteScheduledAction{}, middleware.After)
1503}
1504
1505func addOpDeleteSnapshotCopyGrantValidationMiddleware(stack *middleware.Stack) error {
1506	return stack.Initialize.Add(&validateOpDeleteSnapshotCopyGrant{}, middleware.After)
1507}
1508
1509func addOpDeleteSnapshotScheduleValidationMiddleware(stack *middleware.Stack) error {
1510	return stack.Initialize.Add(&validateOpDeleteSnapshotSchedule{}, middleware.After)
1511}
1512
1513func addOpDeleteTagsValidationMiddleware(stack *middleware.Stack) error {
1514	return stack.Initialize.Add(&validateOpDeleteTags{}, middleware.After)
1515}
1516
1517func addOpDeleteUsageLimitValidationMiddleware(stack *middleware.Stack) error {
1518	return stack.Initialize.Add(&validateOpDeleteUsageLimit{}, middleware.After)
1519}
1520
1521func addOpDescribeClusterParametersValidationMiddleware(stack *middleware.Stack) error {
1522	return stack.Initialize.Add(&validateOpDescribeClusterParameters{}, middleware.After)
1523}
1524
1525func addOpDescribeClusterSnapshotsValidationMiddleware(stack *middleware.Stack) error {
1526	return stack.Initialize.Add(&validateOpDescribeClusterSnapshots{}, middleware.After)
1527}
1528
1529func addOpDescribeDefaultClusterParametersValidationMiddleware(stack *middleware.Stack) error {
1530	return stack.Initialize.Add(&validateOpDescribeDefaultClusterParameters{}, middleware.After)
1531}
1532
1533func addOpDescribeLoggingStatusValidationMiddleware(stack *middleware.Stack) error {
1534	return stack.Initialize.Add(&validateOpDescribeLoggingStatus{}, middleware.After)
1535}
1536
1537func addOpDescribeNodeConfigurationOptionsValidationMiddleware(stack *middleware.Stack) error {
1538	return stack.Initialize.Add(&validateOpDescribeNodeConfigurationOptions{}, middleware.After)
1539}
1540
1541func addOpDescribeResizeValidationMiddleware(stack *middleware.Stack) error {
1542	return stack.Initialize.Add(&validateOpDescribeResize{}, middleware.After)
1543}
1544
1545func addOpDescribeScheduledActionsValidationMiddleware(stack *middleware.Stack) error {
1546	return stack.Initialize.Add(&validateOpDescribeScheduledActions{}, middleware.After)
1547}
1548
1549func addOpDisableLoggingValidationMiddleware(stack *middleware.Stack) error {
1550	return stack.Initialize.Add(&validateOpDisableLogging{}, middleware.After)
1551}
1552
1553func addOpDisableSnapshotCopyValidationMiddleware(stack *middleware.Stack) error {
1554	return stack.Initialize.Add(&validateOpDisableSnapshotCopy{}, middleware.After)
1555}
1556
1557func addOpEnableLoggingValidationMiddleware(stack *middleware.Stack) error {
1558	return stack.Initialize.Add(&validateOpEnableLogging{}, middleware.After)
1559}
1560
1561func addOpEnableSnapshotCopyValidationMiddleware(stack *middleware.Stack) error {
1562	return stack.Initialize.Add(&validateOpEnableSnapshotCopy{}, middleware.After)
1563}
1564
1565func addOpGetClusterCredentialsValidationMiddleware(stack *middleware.Stack) error {
1566	return stack.Initialize.Add(&validateOpGetClusterCredentials{}, middleware.After)
1567}
1568
1569func addOpGetReservedNodeExchangeOfferingsValidationMiddleware(stack *middleware.Stack) error {
1570	return stack.Initialize.Add(&validateOpGetReservedNodeExchangeOfferings{}, middleware.After)
1571}
1572
1573func addOpModifyClusterDbRevisionValidationMiddleware(stack *middleware.Stack) error {
1574	return stack.Initialize.Add(&validateOpModifyClusterDbRevision{}, middleware.After)
1575}
1576
1577func addOpModifyClusterIamRolesValidationMiddleware(stack *middleware.Stack) error {
1578	return stack.Initialize.Add(&validateOpModifyClusterIamRoles{}, middleware.After)
1579}
1580
1581func addOpModifyClusterValidationMiddleware(stack *middleware.Stack) error {
1582	return stack.Initialize.Add(&validateOpModifyCluster{}, middleware.After)
1583}
1584
1585func addOpModifyClusterMaintenanceValidationMiddleware(stack *middleware.Stack) error {
1586	return stack.Initialize.Add(&validateOpModifyClusterMaintenance{}, middleware.After)
1587}
1588
1589func addOpModifyClusterParameterGroupValidationMiddleware(stack *middleware.Stack) error {
1590	return stack.Initialize.Add(&validateOpModifyClusterParameterGroup{}, middleware.After)
1591}
1592
1593func addOpModifyClusterSnapshotValidationMiddleware(stack *middleware.Stack) error {
1594	return stack.Initialize.Add(&validateOpModifyClusterSnapshot{}, middleware.After)
1595}
1596
1597func addOpModifyClusterSnapshotScheduleValidationMiddleware(stack *middleware.Stack) error {
1598	return stack.Initialize.Add(&validateOpModifyClusterSnapshotSchedule{}, middleware.After)
1599}
1600
1601func addOpModifyClusterSubnetGroupValidationMiddleware(stack *middleware.Stack) error {
1602	return stack.Initialize.Add(&validateOpModifyClusterSubnetGroup{}, middleware.After)
1603}
1604
1605func addOpModifyEventSubscriptionValidationMiddleware(stack *middleware.Stack) error {
1606	return stack.Initialize.Add(&validateOpModifyEventSubscription{}, middleware.After)
1607}
1608
1609func addOpModifyScheduledActionValidationMiddleware(stack *middleware.Stack) error {
1610	return stack.Initialize.Add(&validateOpModifyScheduledAction{}, middleware.After)
1611}
1612
1613func addOpModifySnapshotCopyRetentionPeriodValidationMiddleware(stack *middleware.Stack) error {
1614	return stack.Initialize.Add(&validateOpModifySnapshotCopyRetentionPeriod{}, middleware.After)
1615}
1616
1617func addOpModifySnapshotScheduleValidationMiddleware(stack *middleware.Stack) error {
1618	return stack.Initialize.Add(&validateOpModifySnapshotSchedule{}, middleware.After)
1619}
1620
1621func addOpModifyUsageLimitValidationMiddleware(stack *middleware.Stack) error {
1622	return stack.Initialize.Add(&validateOpModifyUsageLimit{}, middleware.After)
1623}
1624
1625func addOpPauseClusterValidationMiddleware(stack *middleware.Stack) error {
1626	return stack.Initialize.Add(&validateOpPauseCluster{}, middleware.After)
1627}
1628
1629func addOpPurchaseReservedNodeOfferingValidationMiddleware(stack *middleware.Stack) error {
1630	return stack.Initialize.Add(&validateOpPurchaseReservedNodeOffering{}, middleware.After)
1631}
1632
1633func addOpRebootClusterValidationMiddleware(stack *middleware.Stack) error {
1634	return stack.Initialize.Add(&validateOpRebootCluster{}, middleware.After)
1635}
1636
1637func addOpResetClusterParameterGroupValidationMiddleware(stack *middleware.Stack) error {
1638	return stack.Initialize.Add(&validateOpResetClusterParameterGroup{}, middleware.After)
1639}
1640
1641func addOpResizeClusterValidationMiddleware(stack *middleware.Stack) error {
1642	return stack.Initialize.Add(&validateOpResizeCluster{}, middleware.After)
1643}
1644
1645func addOpRestoreFromClusterSnapshotValidationMiddleware(stack *middleware.Stack) error {
1646	return stack.Initialize.Add(&validateOpRestoreFromClusterSnapshot{}, middleware.After)
1647}
1648
1649func addOpRestoreTableFromClusterSnapshotValidationMiddleware(stack *middleware.Stack) error {
1650	return stack.Initialize.Add(&validateOpRestoreTableFromClusterSnapshot{}, middleware.After)
1651}
1652
1653func addOpResumeClusterValidationMiddleware(stack *middleware.Stack) error {
1654	return stack.Initialize.Add(&validateOpResumeCluster{}, middleware.After)
1655}
1656
1657func addOpRevokeClusterSecurityGroupIngressValidationMiddleware(stack *middleware.Stack) error {
1658	return stack.Initialize.Add(&validateOpRevokeClusterSecurityGroupIngress{}, middleware.After)
1659}
1660
1661func addOpRevokeSnapshotAccessValidationMiddleware(stack *middleware.Stack) error {
1662	return stack.Initialize.Add(&validateOpRevokeSnapshotAccess{}, middleware.After)
1663}
1664
1665func addOpRotateEncryptionKeyValidationMiddleware(stack *middleware.Stack) error {
1666	return stack.Initialize.Add(&validateOpRotateEncryptionKey{}, middleware.After)
1667}
1668
1669func validateDeleteClusterSnapshotMessage(v *types.DeleteClusterSnapshotMessage) error {
1670	if v == nil {
1671		return nil
1672	}
1673	invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterSnapshotMessage"}
1674	if v.SnapshotIdentifier == nil {
1675		invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier"))
1676	}
1677	if invalidParams.Len() > 0 {
1678		return invalidParams
1679	} else {
1680		return nil
1681	}
1682}
1683
1684func validateDeleteClusterSnapshotMessageList(v []types.DeleteClusterSnapshotMessage) error {
1685	if v == nil {
1686		return nil
1687	}
1688	invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterSnapshotMessageList"}
1689	for i := range v {
1690		if err := validateDeleteClusterSnapshotMessage(&v[i]); err != nil {
1691			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1692		}
1693	}
1694	if invalidParams.Len() > 0 {
1695		return invalidParams
1696	} else {
1697		return nil
1698	}
1699}
1700
1701func validatePauseClusterMessage(v *types.PauseClusterMessage) error {
1702	if v == nil {
1703		return nil
1704	}
1705	invalidParams := smithy.InvalidParamsError{Context: "PauseClusterMessage"}
1706	if v.ClusterIdentifier == nil {
1707		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
1708	}
1709	if invalidParams.Len() > 0 {
1710		return invalidParams
1711	} else {
1712		return nil
1713	}
1714}
1715
1716func validateResizeClusterMessage(v *types.ResizeClusterMessage) error {
1717	if v == nil {
1718		return nil
1719	}
1720	invalidParams := smithy.InvalidParamsError{Context: "ResizeClusterMessage"}
1721	if v.ClusterIdentifier == nil {
1722		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
1723	}
1724	if invalidParams.Len() > 0 {
1725		return invalidParams
1726	} else {
1727		return nil
1728	}
1729}
1730
1731func validateResumeClusterMessage(v *types.ResumeClusterMessage) error {
1732	if v == nil {
1733		return nil
1734	}
1735	invalidParams := smithy.InvalidParamsError{Context: "ResumeClusterMessage"}
1736	if v.ClusterIdentifier == nil {
1737		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
1738	}
1739	if invalidParams.Len() > 0 {
1740		return invalidParams
1741	} else {
1742		return nil
1743	}
1744}
1745
1746func validateScheduledActionFilter(v *types.ScheduledActionFilter) error {
1747	if v == nil {
1748		return nil
1749	}
1750	invalidParams := smithy.InvalidParamsError{Context: "ScheduledActionFilter"}
1751	if len(v.Name) == 0 {
1752		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1753	}
1754	if v.Values == nil {
1755		invalidParams.Add(smithy.NewErrParamRequired("Values"))
1756	}
1757	if invalidParams.Len() > 0 {
1758		return invalidParams
1759	} else {
1760		return nil
1761	}
1762}
1763
1764func validateScheduledActionFilterList(v []types.ScheduledActionFilter) error {
1765	if v == nil {
1766		return nil
1767	}
1768	invalidParams := smithy.InvalidParamsError{Context: "ScheduledActionFilterList"}
1769	for i := range v {
1770		if err := validateScheduledActionFilter(&v[i]); err != nil {
1771			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1772		}
1773	}
1774	if invalidParams.Len() > 0 {
1775		return invalidParams
1776	} else {
1777		return nil
1778	}
1779}
1780
1781func validateScheduledActionType(v *types.ScheduledActionType) error {
1782	if v == nil {
1783		return nil
1784	}
1785	invalidParams := smithy.InvalidParamsError{Context: "ScheduledActionType"}
1786	if v.ResizeCluster != nil {
1787		if err := validateResizeClusterMessage(v.ResizeCluster); err != nil {
1788			invalidParams.AddNested("ResizeCluster", err.(smithy.InvalidParamsError))
1789		}
1790	}
1791	if v.PauseCluster != nil {
1792		if err := validatePauseClusterMessage(v.PauseCluster); err != nil {
1793			invalidParams.AddNested("PauseCluster", err.(smithy.InvalidParamsError))
1794		}
1795	}
1796	if v.ResumeCluster != nil {
1797		if err := validateResumeClusterMessage(v.ResumeCluster); err != nil {
1798			invalidParams.AddNested("ResumeCluster", err.(smithy.InvalidParamsError))
1799		}
1800	}
1801	if invalidParams.Len() > 0 {
1802		return invalidParams
1803	} else {
1804		return nil
1805	}
1806}
1807
1808func validateSnapshotSortingEntity(v *types.SnapshotSortingEntity) error {
1809	if v == nil {
1810		return nil
1811	}
1812	invalidParams := smithy.InvalidParamsError{Context: "SnapshotSortingEntity"}
1813	if len(v.Attribute) == 0 {
1814		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
1815	}
1816	if invalidParams.Len() > 0 {
1817		return invalidParams
1818	} else {
1819		return nil
1820	}
1821}
1822
1823func validateSnapshotSortingEntityList(v []types.SnapshotSortingEntity) error {
1824	if v == nil {
1825		return nil
1826	}
1827	invalidParams := smithy.InvalidParamsError{Context: "SnapshotSortingEntityList"}
1828	for i := range v {
1829		if err := validateSnapshotSortingEntity(&v[i]); err != nil {
1830			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1831		}
1832	}
1833	if invalidParams.Len() > 0 {
1834		return invalidParams
1835	} else {
1836		return nil
1837	}
1838}
1839
1840func validateOpAcceptReservedNodeExchangeInput(v *AcceptReservedNodeExchangeInput) error {
1841	if v == nil {
1842		return nil
1843	}
1844	invalidParams := smithy.InvalidParamsError{Context: "AcceptReservedNodeExchangeInput"}
1845	if v.ReservedNodeId == nil {
1846		invalidParams.Add(smithy.NewErrParamRequired("ReservedNodeId"))
1847	}
1848	if v.TargetReservedNodeOfferingId == nil {
1849		invalidParams.Add(smithy.NewErrParamRequired("TargetReservedNodeOfferingId"))
1850	}
1851	if invalidParams.Len() > 0 {
1852		return invalidParams
1853	} else {
1854		return nil
1855	}
1856}
1857
1858func validateOpAuthorizeClusterSecurityGroupIngressInput(v *AuthorizeClusterSecurityGroupIngressInput) error {
1859	if v == nil {
1860		return nil
1861	}
1862	invalidParams := smithy.InvalidParamsError{Context: "AuthorizeClusterSecurityGroupIngressInput"}
1863	if v.ClusterSecurityGroupName == nil {
1864		invalidParams.Add(smithy.NewErrParamRequired("ClusterSecurityGroupName"))
1865	}
1866	if invalidParams.Len() > 0 {
1867		return invalidParams
1868	} else {
1869		return nil
1870	}
1871}
1872
1873func validateOpAuthorizeSnapshotAccessInput(v *AuthorizeSnapshotAccessInput) error {
1874	if v == nil {
1875		return nil
1876	}
1877	invalidParams := smithy.InvalidParamsError{Context: "AuthorizeSnapshotAccessInput"}
1878	if v.SnapshotIdentifier == nil {
1879		invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier"))
1880	}
1881	if v.AccountWithRestoreAccess == nil {
1882		invalidParams.Add(smithy.NewErrParamRequired("AccountWithRestoreAccess"))
1883	}
1884	if invalidParams.Len() > 0 {
1885		return invalidParams
1886	} else {
1887		return nil
1888	}
1889}
1890
1891func validateOpBatchDeleteClusterSnapshotsInput(v *BatchDeleteClusterSnapshotsInput) error {
1892	if v == nil {
1893		return nil
1894	}
1895	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteClusterSnapshotsInput"}
1896	if v.Identifiers == nil {
1897		invalidParams.Add(smithy.NewErrParamRequired("Identifiers"))
1898	} else if v.Identifiers != nil {
1899		if err := validateDeleteClusterSnapshotMessageList(v.Identifiers); err != nil {
1900			invalidParams.AddNested("Identifiers", err.(smithy.InvalidParamsError))
1901		}
1902	}
1903	if invalidParams.Len() > 0 {
1904		return invalidParams
1905	} else {
1906		return nil
1907	}
1908}
1909
1910func validateOpBatchModifyClusterSnapshotsInput(v *BatchModifyClusterSnapshotsInput) error {
1911	if v == nil {
1912		return nil
1913	}
1914	invalidParams := smithy.InvalidParamsError{Context: "BatchModifyClusterSnapshotsInput"}
1915	if v.SnapshotIdentifierList == nil {
1916		invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifierList"))
1917	}
1918	if invalidParams.Len() > 0 {
1919		return invalidParams
1920	} else {
1921		return nil
1922	}
1923}
1924
1925func validateOpCancelResizeInput(v *CancelResizeInput) error {
1926	if v == nil {
1927		return nil
1928	}
1929	invalidParams := smithy.InvalidParamsError{Context: "CancelResizeInput"}
1930	if v.ClusterIdentifier == nil {
1931		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
1932	}
1933	if invalidParams.Len() > 0 {
1934		return invalidParams
1935	} else {
1936		return nil
1937	}
1938}
1939
1940func validateOpCopyClusterSnapshotInput(v *CopyClusterSnapshotInput) error {
1941	if v == nil {
1942		return nil
1943	}
1944	invalidParams := smithy.InvalidParamsError{Context: "CopyClusterSnapshotInput"}
1945	if v.SourceSnapshotIdentifier == nil {
1946		invalidParams.Add(smithy.NewErrParamRequired("SourceSnapshotIdentifier"))
1947	}
1948	if v.TargetSnapshotIdentifier == nil {
1949		invalidParams.Add(smithy.NewErrParamRequired("TargetSnapshotIdentifier"))
1950	}
1951	if invalidParams.Len() > 0 {
1952		return invalidParams
1953	} else {
1954		return nil
1955	}
1956}
1957
1958func validateOpCreateClusterInput(v *CreateClusterInput) error {
1959	if v == nil {
1960		return nil
1961	}
1962	invalidParams := smithy.InvalidParamsError{Context: "CreateClusterInput"}
1963	if v.ClusterIdentifier == nil {
1964		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
1965	}
1966	if v.NodeType == nil {
1967		invalidParams.Add(smithy.NewErrParamRequired("NodeType"))
1968	}
1969	if v.MasterUsername == nil {
1970		invalidParams.Add(smithy.NewErrParamRequired("MasterUsername"))
1971	}
1972	if v.MasterUserPassword == nil {
1973		invalidParams.Add(smithy.NewErrParamRequired("MasterUserPassword"))
1974	}
1975	if invalidParams.Len() > 0 {
1976		return invalidParams
1977	} else {
1978		return nil
1979	}
1980}
1981
1982func validateOpCreateClusterParameterGroupInput(v *CreateClusterParameterGroupInput) error {
1983	if v == nil {
1984		return nil
1985	}
1986	invalidParams := smithy.InvalidParamsError{Context: "CreateClusterParameterGroupInput"}
1987	if v.ParameterGroupName == nil {
1988		invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName"))
1989	}
1990	if v.ParameterGroupFamily == nil {
1991		invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupFamily"))
1992	}
1993	if v.Description == nil {
1994		invalidParams.Add(smithy.NewErrParamRequired("Description"))
1995	}
1996	if invalidParams.Len() > 0 {
1997		return invalidParams
1998	} else {
1999		return nil
2000	}
2001}
2002
2003func validateOpCreateClusterSecurityGroupInput(v *CreateClusterSecurityGroupInput) error {
2004	if v == nil {
2005		return nil
2006	}
2007	invalidParams := smithy.InvalidParamsError{Context: "CreateClusterSecurityGroupInput"}
2008	if v.ClusterSecurityGroupName == nil {
2009		invalidParams.Add(smithy.NewErrParamRequired("ClusterSecurityGroupName"))
2010	}
2011	if v.Description == nil {
2012		invalidParams.Add(smithy.NewErrParamRequired("Description"))
2013	}
2014	if invalidParams.Len() > 0 {
2015		return invalidParams
2016	} else {
2017		return nil
2018	}
2019}
2020
2021func validateOpCreateClusterSnapshotInput(v *CreateClusterSnapshotInput) error {
2022	if v == nil {
2023		return nil
2024	}
2025	invalidParams := smithy.InvalidParamsError{Context: "CreateClusterSnapshotInput"}
2026	if v.SnapshotIdentifier == nil {
2027		invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier"))
2028	}
2029	if v.ClusterIdentifier == nil {
2030		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2031	}
2032	if invalidParams.Len() > 0 {
2033		return invalidParams
2034	} else {
2035		return nil
2036	}
2037}
2038
2039func validateOpCreateClusterSubnetGroupInput(v *CreateClusterSubnetGroupInput) error {
2040	if v == nil {
2041		return nil
2042	}
2043	invalidParams := smithy.InvalidParamsError{Context: "CreateClusterSubnetGroupInput"}
2044	if v.ClusterSubnetGroupName == nil {
2045		invalidParams.Add(smithy.NewErrParamRequired("ClusterSubnetGroupName"))
2046	}
2047	if v.Description == nil {
2048		invalidParams.Add(smithy.NewErrParamRequired("Description"))
2049	}
2050	if v.SubnetIds == nil {
2051		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
2052	}
2053	if invalidParams.Len() > 0 {
2054		return invalidParams
2055	} else {
2056		return nil
2057	}
2058}
2059
2060func validateOpCreateEventSubscriptionInput(v *CreateEventSubscriptionInput) error {
2061	if v == nil {
2062		return nil
2063	}
2064	invalidParams := smithy.InvalidParamsError{Context: "CreateEventSubscriptionInput"}
2065	if v.SubscriptionName == nil {
2066		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionName"))
2067	}
2068	if v.SnsTopicArn == nil {
2069		invalidParams.Add(smithy.NewErrParamRequired("SnsTopicArn"))
2070	}
2071	if invalidParams.Len() > 0 {
2072		return invalidParams
2073	} else {
2074		return nil
2075	}
2076}
2077
2078func validateOpCreateHsmClientCertificateInput(v *CreateHsmClientCertificateInput) error {
2079	if v == nil {
2080		return nil
2081	}
2082	invalidParams := smithy.InvalidParamsError{Context: "CreateHsmClientCertificateInput"}
2083	if v.HsmClientCertificateIdentifier == nil {
2084		invalidParams.Add(smithy.NewErrParamRequired("HsmClientCertificateIdentifier"))
2085	}
2086	if invalidParams.Len() > 0 {
2087		return invalidParams
2088	} else {
2089		return nil
2090	}
2091}
2092
2093func validateOpCreateHsmConfigurationInput(v *CreateHsmConfigurationInput) error {
2094	if v == nil {
2095		return nil
2096	}
2097	invalidParams := smithy.InvalidParamsError{Context: "CreateHsmConfigurationInput"}
2098	if v.HsmConfigurationIdentifier == nil {
2099		invalidParams.Add(smithy.NewErrParamRequired("HsmConfigurationIdentifier"))
2100	}
2101	if v.Description == nil {
2102		invalidParams.Add(smithy.NewErrParamRequired("Description"))
2103	}
2104	if v.HsmIpAddress == nil {
2105		invalidParams.Add(smithy.NewErrParamRequired("HsmIpAddress"))
2106	}
2107	if v.HsmPartitionName == nil {
2108		invalidParams.Add(smithy.NewErrParamRequired("HsmPartitionName"))
2109	}
2110	if v.HsmPartitionPassword == nil {
2111		invalidParams.Add(smithy.NewErrParamRequired("HsmPartitionPassword"))
2112	}
2113	if v.HsmServerPublicCertificate == nil {
2114		invalidParams.Add(smithy.NewErrParamRequired("HsmServerPublicCertificate"))
2115	}
2116	if invalidParams.Len() > 0 {
2117		return invalidParams
2118	} else {
2119		return nil
2120	}
2121}
2122
2123func validateOpCreateScheduledActionInput(v *CreateScheduledActionInput) error {
2124	if v == nil {
2125		return nil
2126	}
2127	invalidParams := smithy.InvalidParamsError{Context: "CreateScheduledActionInput"}
2128	if v.ScheduledActionName == nil {
2129		invalidParams.Add(smithy.NewErrParamRequired("ScheduledActionName"))
2130	}
2131	if v.TargetAction == nil {
2132		invalidParams.Add(smithy.NewErrParamRequired("TargetAction"))
2133	} else if v.TargetAction != nil {
2134		if err := validateScheduledActionType(v.TargetAction); err != nil {
2135			invalidParams.AddNested("TargetAction", err.(smithy.InvalidParamsError))
2136		}
2137	}
2138	if v.Schedule == nil {
2139		invalidParams.Add(smithy.NewErrParamRequired("Schedule"))
2140	}
2141	if v.IamRole == nil {
2142		invalidParams.Add(smithy.NewErrParamRequired("IamRole"))
2143	}
2144	if invalidParams.Len() > 0 {
2145		return invalidParams
2146	} else {
2147		return nil
2148	}
2149}
2150
2151func validateOpCreateSnapshotCopyGrantInput(v *CreateSnapshotCopyGrantInput) error {
2152	if v == nil {
2153		return nil
2154	}
2155	invalidParams := smithy.InvalidParamsError{Context: "CreateSnapshotCopyGrantInput"}
2156	if v.SnapshotCopyGrantName == nil {
2157		invalidParams.Add(smithy.NewErrParamRequired("SnapshotCopyGrantName"))
2158	}
2159	if invalidParams.Len() > 0 {
2160		return invalidParams
2161	} else {
2162		return nil
2163	}
2164}
2165
2166func validateOpCreateTagsInput(v *CreateTagsInput) error {
2167	if v == nil {
2168		return nil
2169	}
2170	invalidParams := smithy.InvalidParamsError{Context: "CreateTagsInput"}
2171	if v.ResourceName == nil {
2172		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
2173	}
2174	if v.Tags == nil {
2175		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
2176	}
2177	if invalidParams.Len() > 0 {
2178		return invalidParams
2179	} else {
2180		return nil
2181	}
2182}
2183
2184func validateOpCreateUsageLimitInput(v *CreateUsageLimitInput) error {
2185	if v == nil {
2186		return nil
2187	}
2188	invalidParams := smithy.InvalidParamsError{Context: "CreateUsageLimitInput"}
2189	if v.ClusterIdentifier == nil {
2190		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2191	}
2192	if len(v.FeatureType) == 0 {
2193		invalidParams.Add(smithy.NewErrParamRequired("FeatureType"))
2194	}
2195	if len(v.LimitType) == 0 {
2196		invalidParams.Add(smithy.NewErrParamRequired("LimitType"))
2197	}
2198	if invalidParams.Len() > 0 {
2199		return invalidParams
2200	} else {
2201		return nil
2202	}
2203}
2204
2205func validateOpDeleteClusterInput(v *DeleteClusterInput) error {
2206	if v == nil {
2207		return nil
2208	}
2209	invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterInput"}
2210	if v.ClusterIdentifier == nil {
2211		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2212	}
2213	if invalidParams.Len() > 0 {
2214		return invalidParams
2215	} else {
2216		return nil
2217	}
2218}
2219
2220func validateOpDeleteClusterParameterGroupInput(v *DeleteClusterParameterGroupInput) error {
2221	if v == nil {
2222		return nil
2223	}
2224	invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterParameterGroupInput"}
2225	if v.ParameterGroupName == nil {
2226		invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName"))
2227	}
2228	if invalidParams.Len() > 0 {
2229		return invalidParams
2230	} else {
2231		return nil
2232	}
2233}
2234
2235func validateOpDeleteClusterSecurityGroupInput(v *DeleteClusterSecurityGroupInput) error {
2236	if v == nil {
2237		return nil
2238	}
2239	invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterSecurityGroupInput"}
2240	if v.ClusterSecurityGroupName == nil {
2241		invalidParams.Add(smithy.NewErrParamRequired("ClusterSecurityGroupName"))
2242	}
2243	if invalidParams.Len() > 0 {
2244		return invalidParams
2245	} else {
2246		return nil
2247	}
2248}
2249
2250func validateOpDeleteClusterSnapshotInput(v *DeleteClusterSnapshotInput) error {
2251	if v == nil {
2252		return nil
2253	}
2254	invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterSnapshotInput"}
2255	if v.SnapshotIdentifier == nil {
2256		invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier"))
2257	}
2258	if invalidParams.Len() > 0 {
2259		return invalidParams
2260	} else {
2261		return nil
2262	}
2263}
2264
2265func validateOpDeleteClusterSubnetGroupInput(v *DeleteClusterSubnetGroupInput) error {
2266	if v == nil {
2267		return nil
2268	}
2269	invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterSubnetGroupInput"}
2270	if v.ClusterSubnetGroupName == nil {
2271		invalidParams.Add(smithy.NewErrParamRequired("ClusterSubnetGroupName"))
2272	}
2273	if invalidParams.Len() > 0 {
2274		return invalidParams
2275	} else {
2276		return nil
2277	}
2278}
2279
2280func validateOpDeleteEventSubscriptionInput(v *DeleteEventSubscriptionInput) error {
2281	if v == nil {
2282		return nil
2283	}
2284	invalidParams := smithy.InvalidParamsError{Context: "DeleteEventSubscriptionInput"}
2285	if v.SubscriptionName == nil {
2286		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionName"))
2287	}
2288	if invalidParams.Len() > 0 {
2289		return invalidParams
2290	} else {
2291		return nil
2292	}
2293}
2294
2295func validateOpDeleteHsmClientCertificateInput(v *DeleteHsmClientCertificateInput) error {
2296	if v == nil {
2297		return nil
2298	}
2299	invalidParams := smithy.InvalidParamsError{Context: "DeleteHsmClientCertificateInput"}
2300	if v.HsmClientCertificateIdentifier == nil {
2301		invalidParams.Add(smithy.NewErrParamRequired("HsmClientCertificateIdentifier"))
2302	}
2303	if invalidParams.Len() > 0 {
2304		return invalidParams
2305	} else {
2306		return nil
2307	}
2308}
2309
2310func validateOpDeleteHsmConfigurationInput(v *DeleteHsmConfigurationInput) error {
2311	if v == nil {
2312		return nil
2313	}
2314	invalidParams := smithy.InvalidParamsError{Context: "DeleteHsmConfigurationInput"}
2315	if v.HsmConfigurationIdentifier == nil {
2316		invalidParams.Add(smithy.NewErrParamRequired("HsmConfigurationIdentifier"))
2317	}
2318	if invalidParams.Len() > 0 {
2319		return invalidParams
2320	} else {
2321		return nil
2322	}
2323}
2324
2325func validateOpDeleteScheduledActionInput(v *DeleteScheduledActionInput) error {
2326	if v == nil {
2327		return nil
2328	}
2329	invalidParams := smithy.InvalidParamsError{Context: "DeleteScheduledActionInput"}
2330	if v.ScheduledActionName == nil {
2331		invalidParams.Add(smithy.NewErrParamRequired("ScheduledActionName"))
2332	}
2333	if invalidParams.Len() > 0 {
2334		return invalidParams
2335	} else {
2336		return nil
2337	}
2338}
2339
2340func validateOpDeleteSnapshotCopyGrantInput(v *DeleteSnapshotCopyGrantInput) error {
2341	if v == nil {
2342		return nil
2343	}
2344	invalidParams := smithy.InvalidParamsError{Context: "DeleteSnapshotCopyGrantInput"}
2345	if v.SnapshotCopyGrantName == nil {
2346		invalidParams.Add(smithy.NewErrParamRequired("SnapshotCopyGrantName"))
2347	}
2348	if invalidParams.Len() > 0 {
2349		return invalidParams
2350	} else {
2351		return nil
2352	}
2353}
2354
2355func validateOpDeleteSnapshotScheduleInput(v *DeleteSnapshotScheduleInput) error {
2356	if v == nil {
2357		return nil
2358	}
2359	invalidParams := smithy.InvalidParamsError{Context: "DeleteSnapshotScheduleInput"}
2360	if v.ScheduleIdentifier == nil {
2361		invalidParams.Add(smithy.NewErrParamRequired("ScheduleIdentifier"))
2362	}
2363	if invalidParams.Len() > 0 {
2364		return invalidParams
2365	} else {
2366		return nil
2367	}
2368}
2369
2370func validateOpDeleteTagsInput(v *DeleteTagsInput) error {
2371	if v == nil {
2372		return nil
2373	}
2374	invalidParams := smithy.InvalidParamsError{Context: "DeleteTagsInput"}
2375	if v.ResourceName == nil {
2376		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
2377	}
2378	if v.TagKeys == nil {
2379		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
2380	}
2381	if invalidParams.Len() > 0 {
2382		return invalidParams
2383	} else {
2384		return nil
2385	}
2386}
2387
2388func validateOpDeleteUsageLimitInput(v *DeleteUsageLimitInput) error {
2389	if v == nil {
2390		return nil
2391	}
2392	invalidParams := smithy.InvalidParamsError{Context: "DeleteUsageLimitInput"}
2393	if v.UsageLimitId == nil {
2394		invalidParams.Add(smithy.NewErrParamRequired("UsageLimitId"))
2395	}
2396	if invalidParams.Len() > 0 {
2397		return invalidParams
2398	} else {
2399		return nil
2400	}
2401}
2402
2403func validateOpDescribeClusterParametersInput(v *DescribeClusterParametersInput) error {
2404	if v == nil {
2405		return nil
2406	}
2407	invalidParams := smithy.InvalidParamsError{Context: "DescribeClusterParametersInput"}
2408	if v.ParameterGroupName == nil {
2409		invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName"))
2410	}
2411	if invalidParams.Len() > 0 {
2412		return invalidParams
2413	} else {
2414		return nil
2415	}
2416}
2417
2418func validateOpDescribeClusterSnapshotsInput(v *DescribeClusterSnapshotsInput) error {
2419	if v == nil {
2420		return nil
2421	}
2422	invalidParams := smithy.InvalidParamsError{Context: "DescribeClusterSnapshotsInput"}
2423	if v.SortingEntities != nil {
2424		if err := validateSnapshotSortingEntityList(v.SortingEntities); err != nil {
2425			invalidParams.AddNested("SortingEntities", err.(smithy.InvalidParamsError))
2426		}
2427	}
2428	if invalidParams.Len() > 0 {
2429		return invalidParams
2430	} else {
2431		return nil
2432	}
2433}
2434
2435func validateOpDescribeDefaultClusterParametersInput(v *DescribeDefaultClusterParametersInput) error {
2436	if v == nil {
2437		return nil
2438	}
2439	invalidParams := smithy.InvalidParamsError{Context: "DescribeDefaultClusterParametersInput"}
2440	if v.ParameterGroupFamily == nil {
2441		invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupFamily"))
2442	}
2443	if invalidParams.Len() > 0 {
2444		return invalidParams
2445	} else {
2446		return nil
2447	}
2448}
2449
2450func validateOpDescribeLoggingStatusInput(v *DescribeLoggingStatusInput) error {
2451	if v == nil {
2452		return nil
2453	}
2454	invalidParams := smithy.InvalidParamsError{Context: "DescribeLoggingStatusInput"}
2455	if v.ClusterIdentifier == nil {
2456		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2457	}
2458	if invalidParams.Len() > 0 {
2459		return invalidParams
2460	} else {
2461		return nil
2462	}
2463}
2464
2465func validateOpDescribeNodeConfigurationOptionsInput(v *DescribeNodeConfigurationOptionsInput) error {
2466	if v == nil {
2467		return nil
2468	}
2469	invalidParams := smithy.InvalidParamsError{Context: "DescribeNodeConfigurationOptionsInput"}
2470	if len(v.ActionType) == 0 {
2471		invalidParams.Add(smithy.NewErrParamRequired("ActionType"))
2472	}
2473	if invalidParams.Len() > 0 {
2474		return invalidParams
2475	} else {
2476		return nil
2477	}
2478}
2479
2480func validateOpDescribeResizeInput(v *DescribeResizeInput) error {
2481	if v == nil {
2482		return nil
2483	}
2484	invalidParams := smithy.InvalidParamsError{Context: "DescribeResizeInput"}
2485	if v.ClusterIdentifier == nil {
2486		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2487	}
2488	if invalidParams.Len() > 0 {
2489		return invalidParams
2490	} else {
2491		return nil
2492	}
2493}
2494
2495func validateOpDescribeScheduledActionsInput(v *DescribeScheduledActionsInput) error {
2496	if v == nil {
2497		return nil
2498	}
2499	invalidParams := smithy.InvalidParamsError{Context: "DescribeScheduledActionsInput"}
2500	if v.Filters != nil {
2501		if err := validateScheduledActionFilterList(v.Filters); err != nil {
2502			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
2503		}
2504	}
2505	if invalidParams.Len() > 0 {
2506		return invalidParams
2507	} else {
2508		return nil
2509	}
2510}
2511
2512func validateOpDisableLoggingInput(v *DisableLoggingInput) error {
2513	if v == nil {
2514		return nil
2515	}
2516	invalidParams := smithy.InvalidParamsError{Context: "DisableLoggingInput"}
2517	if v.ClusterIdentifier == nil {
2518		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2519	}
2520	if invalidParams.Len() > 0 {
2521		return invalidParams
2522	} else {
2523		return nil
2524	}
2525}
2526
2527func validateOpDisableSnapshotCopyInput(v *DisableSnapshotCopyInput) error {
2528	if v == nil {
2529		return nil
2530	}
2531	invalidParams := smithy.InvalidParamsError{Context: "DisableSnapshotCopyInput"}
2532	if v.ClusterIdentifier == nil {
2533		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2534	}
2535	if invalidParams.Len() > 0 {
2536		return invalidParams
2537	} else {
2538		return nil
2539	}
2540}
2541
2542func validateOpEnableLoggingInput(v *EnableLoggingInput) error {
2543	if v == nil {
2544		return nil
2545	}
2546	invalidParams := smithy.InvalidParamsError{Context: "EnableLoggingInput"}
2547	if v.ClusterIdentifier == nil {
2548		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2549	}
2550	if v.BucketName == nil {
2551		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
2552	}
2553	if invalidParams.Len() > 0 {
2554		return invalidParams
2555	} else {
2556		return nil
2557	}
2558}
2559
2560func validateOpEnableSnapshotCopyInput(v *EnableSnapshotCopyInput) error {
2561	if v == nil {
2562		return nil
2563	}
2564	invalidParams := smithy.InvalidParamsError{Context: "EnableSnapshotCopyInput"}
2565	if v.ClusterIdentifier == nil {
2566		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2567	}
2568	if v.DestinationRegion == nil {
2569		invalidParams.Add(smithy.NewErrParamRequired("DestinationRegion"))
2570	}
2571	if invalidParams.Len() > 0 {
2572		return invalidParams
2573	} else {
2574		return nil
2575	}
2576}
2577
2578func validateOpGetClusterCredentialsInput(v *GetClusterCredentialsInput) error {
2579	if v == nil {
2580		return nil
2581	}
2582	invalidParams := smithy.InvalidParamsError{Context: "GetClusterCredentialsInput"}
2583	if v.DbUser == nil {
2584		invalidParams.Add(smithy.NewErrParamRequired("DbUser"))
2585	}
2586	if v.ClusterIdentifier == nil {
2587		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2588	}
2589	if invalidParams.Len() > 0 {
2590		return invalidParams
2591	} else {
2592		return nil
2593	}
2594}
2595
2596func validateOpGetReservedNodeExchangeOfferingsInput(v *GetReservedNodeExchangeOfferingsInput) error {
2597	if v == nil {
2598		return nil
2599	}
2600	invalidParams := smithy.InvalidParamsError{Context: "GetReservedNodeExchangeOfferingsInput"}
2601	if v.ReservedNodeId == nil {
2602		invalidParams.Add(smithy.NewErrParamRequired("ReservedNodeId"))
2603	}
2604	if invalidParams.Len() > 0 {
2605		return invalidParams
2606	} else {
2607		return nil
2608	}
2609}
2610
2611func validateOpModifyClusterDbRevisionInput(v *ModifyClusterDbRevisionInput) error {
2612	if v == nil {
2613		return nil
2614	}
2615	invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterDbRevisionInput"}
2616	if v.ClusterIdentifier == nil {
2617		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2618	}
2619	if v.RevisionTarget == nil {
2620		invalidParams.Add(smithy.NewErrParamRequired("RevisionTarget"))
2621	}
2622	if invalidParams.Len() > 0 {
2623		return invalidParams
2624	} else {
2625		return nil
2626	}
2627}
2628
2629func validateOpModifyClusterIamRolesInput(v *ModifyClusterIamRolesInput) error {
2630	if v == nil {
2631		return nil
2632	}
2633	invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterIamRolesInput"}
2634	if v.ClusterIdentifier == nil {
2635		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2636	}
2637	if invalidParams.Len() > 0 {
2638		return invalidParams
2639	} else {
2640		return nil
2641	}
2642}
2643
2644func validateOpModifyClusterInput(v *ModifyClusterInput) error {
2645	if v == nil {
2646		return nil
2647	}
2648	invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterInput"}
2649	if v.ClusterIdentifier == nil {
2650		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2651	}
2652	if invalidParams.Len() > 0 {
2653		return invalidParams
2654	} else {
2655		return nil
2656	}
2657}
2658
2659func validateOpModifyClusterMaintenanceInput(v *ModifyClusterMaintenanceInput) error {
2660	if v == nil {
2661		return nil
2662	}
2663	invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterMaintenanceInput"}
2664	if v.ClusterIdentifier == nil {
2665		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2666	}
2667	if invalidParams.Len() > 0 {
2668		return invalidParams
2669	} else {
2670		return nil
2671	}
2672}
2673
2674func validateOpModifyClusterParameterGroupInput(v *ModifyClusterParameterGroupInput) error {
2675	if v == nil {
2676		return nil
2677	}
2678	invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterParameterGroupInput"}
2679	if v.ParameterGroupName == nil {
2680		invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName"))
2681	}
2682	if v.Parameters == nil {
2683		invalidParams.Add(smithy.NewErrParamRequired("Parameters"))
2684	}
2685	if invalidParams.Len() > 0 {
2686		return invalidParams
2687	} else {
2688		return nil
2689	}
2690}
2691
2692func validateOpModifyClusterSnapshotInput(v *ModifyClusterSnapshotInput) error {
2693	if v == nil {
2694		return nil
2695	}
2696	invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterSnapshotInput"}
2697	if v.SnapshotIdentifier == nil {
2698		invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier"))
2699	}
2700	if invalidParams.Len() > 0 {
2701		return invalidParams
2702	} else {
2703		return nil
2704	}
2705}
2706
2707func validateOpModifyClusterSnapshotScheduleInput(v *ModifyClusterSnapshotScheduleInput) error {
2708	if v == nil {
2709		return nil
2710	}
2711	invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterSnapshotScheduleInput"}
2712	if v.ClusterIdentifier == nil {
2713		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2714	}
2715	if invalidParams.Len() > 0 {
2716		return invalidParams
2717	} else {
2718		return nil
2719	}
2720}
2721
2722func validateOpModifyClusterSubnetGroupInput(v *ModifyClusterSubnetGroupInput) error {
2723	if v == nil {
2724		return nil
2725	}
2726	invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterSubnetGroupInput"}
2727	if v.ClusterSubnetGroupName == nil {
2728		invalidParams.Add(smithy.NewErrParamRequired("ClusterSubnetGroupName"))
2729	}
2730	if v.SubnetIds == nil {
2731		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
2732	}
2733	if invalidParams.Len() > 0 {
2734		return invalidParams
2735	} else {
2736		return nil
2737	}
2738}
2739
2740func validateOpModifyEventSubscriptionInput(v *ModifyEventSubscriptionInput) error {
2741	if v == nil {
2742		return nil
2743	}
2744	invalidParams := smithy.InvalidParamsError{Context: "ModifyEventSubscriptionInput"}
2745	if v.SubscriptionName == nil {
2746		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionName"))
2747	}
2748	if invalidParams.Len() > 0 {
2749		return invalidParams
2750	} else {
2751		return nil
2752	}
2753}
2754
2755func validateOpModifyScheduledActionInput(v *ModifyScheduledActionInput) error {
2756	if v == nil {
2757		return nil
2758	}
2759	invalidParams := smithy.InvalidParamsError{Context: "ModifyScheduledActionInput"}
2760	if v.ScheduledActionName == nil {
2761		invalidParams.Add(smithy.NewErrParamRequired("ScheduledActionName"))
2762	}
2763	if v.TargetAction != nil {
2764		if err := validateScheduledActionType(v.TargetAction); err != nil {
2765			invalidParams.AddNested("TargetAction", err.(smithy.InvalidParamsError))
2766		}
2767	}
2768	if invalidParams.Len() > 0 {
2769		return invalidParams
2770	} else {
2771		return nil
2772	}
2773}
2774
2775func validateOpModifySnapshotCopyRetentionPeriodInput(v *ModifySnapshotCopyRetentionPeriodInput) error {
2776	if v == nil {
2777		return nil
2778	}
2779	invalidParams := smithy.InvalidParamsError{Context: "ModifySnapshotCopyRetentionPeriodInput"}
2780	if v.ClusterIdentifier == nil {
2781		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2782	}
2783	if invalidParams.Len() > 0 {
2784		return invalidParams
2785	} else {
2786		return nil
2787	}
2788}
2789
2790func validateOpModifySnapshotScheduleInput(v *ModifySnapshotScheduleInput) error {
2791	if v == nil {
2792		return nil
2793	}
2794	invalidParams := smithy.InvalidParamsError{Context: "ModifySnapshotScheduleInput"}
2795	if v.ScheduleIdentifier == nil {
2796		invalidParams.Add(smithy.NewErrParamRequired("ScheduleIdentifier"))
2797	}
2798	if v.ScheduleDefinitions == nil {
2799		invalidParams.Add(smithy.NewErrParamRequired("ScheduleDefinitions"))
2800	}
2801	if invalidParams.Len() > 0 {
2802		return invalidParams
2803	} else {
2804		return nil
2805	}
2806}
2807
2808func validateOpModifyUsageLimitInput(v *ModifyUsageLimitInput) error {
2809	if v == nil {
2810		return nil
2811	}
2812	invalidParams := smithy.InvalidParamsError{Context: "ModifyUsageLimitInput"}
2813	if v.UsageLimitId == nil {
2814		invalidParams.Add(smithy.NewErrParamRequired("UsageLimitId"))
2815	}
2816	if invalidParams.Len() > 0 {
2817		return invalidParams
2818	} else {
2819		return nil
2820	}
2821}
2822
2823func validateOpPauseClusterInput(v *PauseClusterInput) error {
2824	if v == nil {
2825		return nil
2826	}
2827	invalidParams := smithy.InvalidParamsError{Context: "PauseClusterInput"}
2828	if v.ClusterIdentifier == nil {
2829		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2830	}
2831	if invalidParams.Len() > 0 {
2832		return invalidParams
2833	} else {
2834		return nil
2835	}
2836}
2837
2838func validateOpPurchaseReservedNodeOfferingInput(v *PurchaseReservedNodeOfferingInput) error {
2839	if v == nil {
2840		return nil
2841	}
2842	invalidParams := smithy.InvalidParamsError{Context: "PurchaseReservedNodeOfferingInput"}
2843	if v.ReservedNodeOfferingId == nil {
2844		invalidParams.Add(smithy.NewErrParamRequired("ReservedNodeOfferingId"))
2845	}
2846	if invalidParams.Len() > 0 {
2847		return invalidParams
2848	} else {
2849		return nil
2850	}
2851}
2852
2853func validateOpRebootClusterInput(v *RebootClusterInput) error {
2854	if v == nil {
2855		return nil
2856	}
2857	invalidParams := smithy.InvalidParamsError{Context: "RebootClusterInput"}
2858	if v.ClusterIdentifier == nil {
2859		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2860	}
2861	if invalidParams.Len() > 0 {
2862		return invalidParams
2863	} else {
2864		return nil
2865	}
2866}
2867
2868func validateOpResetClusterParameterGroupInput(v *ResetClusterParameterGroupInput) error {
2869	if v == nil {
2870		return nil
2871	}
2872	invalidParams := smithy.InvalidParamsError{Context: "ResetClusterParameterGroupInput"}
2873	if v.ParameterGroupName == nil {
2874		invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName"))
2875	}
2876	if invalidParams.Len() > 0 {
2877		return invalidParams
2878	} else {
2879		return nil
2880	}
2881}
2882
2883func validateOpResizeClusterInput(v *ResizeClusterInput) error {
2884	if v == nil {
2885		return nil
2886	}
2887	invalidParams := smithy.InvalidParamsError{Context: "ResizeClusterInput"}
2888	if v.ClusterIdentifier == nil {
2889		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2890	}
2891	if invalidParams.Len() > 0 {
2892		return invalidParams
2893	} else {
2894		return nil
2895	}
2896}
2897
2898func validateOpRestoreFromClusterSnapshotInput(v *RestoreFromClusterSnapshotInput) error {
2899	if v == nil {
2900		return nil
2901	}
2902	invalidParams := smithy.InvalidParamsError{Context: "RestoreFromClusterSnapshotInput"}
2903	if v.ClusterIdentifier == nil {
2904		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2905	}
2906	if v.SnapshotIdentifier == nil {
2907		invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier"))
2908	}
2909	if invalidParams.Len() > 0 {
2910		return invalidParams
2911	} else {
2912		return nil
2913	}
2914}
2915
2916func validateOpRestoreTableFromClusterSnapshotInput(v *RestoreTableFromClusterSnapshotInput) error {
2917	if v == nil {
2918		return nil
2919	}
2920	invalidParams := smithy.InvalidParamsError{Context: "RestoreTableFromClusterSnapshotInput"}
2921	if v.ClusterIdentifier == nil {
2922		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2923	}
2924	if v.SnapshotIdentifier == nil {
2925		invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier"))
2926	}
2927	if v.SourceDatabaseName == nil {
2928		invalidParams.Add(smithy.NewErrParamRequired("SourceDatabaseName"))
2929	}
2930	if v.SourceTableName == nil {
2931		invalidParams.Add(smithy.NewErrParamRequired("SourceTableName"))
2932	}
2933	if v.NewTableName == nil {
2934		invalidParams.Add(smithy.NewErrParamRequired("NewTableName"))
2935	}
2936	if invalidParams.Len() > 0 {
2937		return invalidParams
2938	} else {
2939		return nil
2940	}
2941}
2942
2943func validateOpResumeClusterInput(v *ResumeClusterInput) error {
2944	if v == nil {
2945		return nil
2946	}
2947	invalidParams := smithy.InvalidParamsError{Context: "ResumeClusterInput"}
2948	if v.ClusterIdentifier == nil {
2949		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2950	}
2951	if invalidParams.Len() > 0 {
2952		return invalidParams
2953	} else {
2954		return nil
2955	}
2956}
2957
2958func validateOpRevokeClusterSecurityGroupIngressInput(v *RevokeClusterSecurityGroupIngressInput) error {
2959	if v == nil {
2960		return nil
2961	}
2962	invalidParams := smithy.InvalidParamsError{Context: "RevokeClusterSecurityGroupIngressInput"}
2963	if v.ClusterSecurityGroupName == nil {
2964		invalidParams.Add(smithy.NewErrParamRequired("ClusterSecurityGroupName"))
2965	}
2966	if invalidParams.Len() > 0 {
2967		return invalidParams
2968	} else {
2969		return nil
2970	}
2971}
2972
2973func validateOpRevokeSnapshotAccessInput(v *RevokeSnapshotAccessInput) error {
2974	if v == nil {
2975		return nil
2976	}
2977	invalidParams := smithy.InvalidParamsError{Context: "RevokeSnapshotAccessInput"}
2978	if v.SnapshotIdentifier == nil {
2979		invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier"))
2980	}
2981	if v.AccountWithRestoreAccess == nil {
2982		invalidParams.Add(smithy.NewErrParamRequired("AccountWithRestoreAccess"))
2983	}
2984	if invalidParams.Len() > 0 {
2985		return invalidParams
2986	} else {
2987		return nil
2988	}
2989}
2990
2991func validateOpRotateEncryptionKeyInput(v *RotateEncryptionKeyInput) error {
2992	if v == nil {
2993		return nil
2994	}
2995	invalidParams := smithy.InvalidParamsError{Context: "RotateEncryptionKeyInput"}
2996	if v.ClusterIdentifier == nil {
2997		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
2998	}
2999	if invalidParams.Len() > 0 {
3000		return invalidParams
3001	} else {
3002		return nil
3003	}
3004}
3005