1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package elasticache
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/elasticache/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpAddTagsToResource struct {
14}
15
16func (*validateOpAddTagsToResource) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpAddTagsToResource) 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.(*AddTagsToResourceInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpAddTagsToResourceInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpAuthorizeCacheSecurityGroupIngress struct {
34}
35
36func (*validateOpAuthorizeCacheSecurityGroupIngress) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpAuthorizeCacheSecurityGroupIngress) 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.(*AuthorizeCacheSecurityGroupIngressInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpAuthorizeCacheSecurityGroupIngressInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpBatchApplyUpdateAction struct {
54}
55
56func (*validateOpBatchApplyUpdateAction) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpBatchApplyUpdateAction) 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.(*BatchApplyUpdateActionInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpBatchApplyUpdateActionInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpBatchStopUpdateAction struct {
74}
75
76func (*validateOpBatchStopUpdateAction) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpBatchStopUpdateAction) 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.(*BatchStopUpdateActionInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpBatchStopUpdateActionInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCompleteMigration struct {
94}
95
96func (*validateOpCompleteMigration) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCompleteMigration) 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.(*CompleteMigrationInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCompleteMigrationInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCopySnapshot struct {
114}
115
116func (*validateOpCopySnapshot) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCopySnapshot) 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.(*CopySnapshotInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCopySnapshotInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpCreateCacheCluster struct {
134}
135
136func (*validateOpCreateCacheCluster) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpCreateCacheCluster) 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.(*CreateCacheClusterInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpCreateCacheClusterInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpCreateCacheParameterGroup struct {
154}
155
156func (*validateOpCreateCacheParameterGroup) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpCreateCacheParameterGroup) 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.(*CreateCacheParameterGroupInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpCreateCacheParameterGroupInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpCreateCacheSecurityGroup struct {
174}
175
176func (*validateOpCreateCacheSecurityGroup) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpCreateCacheSecurityGroup) 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.(*CreateCacheSecurityGroupInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpCreateCacheSecurityGroupInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpCreateCacheSubnetGroup struct {
194}
195
196func (*validateOpCreateCacheSubnetGroup) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpCreateCacheSubnetGroup) 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.(*CreateCacheSubnetGroupInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpCreateCacheSubnetGroupInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpCreateGlobalReplicationGroup struct {
214}
215
216func (*validateOpCreateGlobalReplicationGroup) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpCreateGlobalReplicationGroup) 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.(*CreateGlobalReplicationGroupInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpCreateGlobalReplicationGroupInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpCreateReplicationGroup struct {
234}
235
236func (*validateOpCreateReplicationGroup) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpCreateReplicationGroup) 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.(*CreateReplicationGroupInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpCreateReplicationGroupInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpCreateSnapshot struct {
254}
255
256func (*validateOpCreateSnapshot) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpCreateSnapshot) 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.(*CreateSnapshotInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpCreateSnapshotInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpCreateUserGroup struct {
274}
275
276func (*validateOpCreateUserGroup) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpCreateUserGroup) 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.(*CreateUserGroupInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpCreateUserGroupInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpCreateUser struct {
294}
295
296func (*validateOpCreateUser) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpCreateUser) 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.(*CreateUserInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpCreateUserInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDecreaseNodeGroupsInGlobalReplicationGroup struct {
314}
315
316func (*validateOpDecreaseNodeGroupsInGlobalReplicationGroup) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDecreaseNodeGroupsInGlobalReplicationGroup) 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.(*DecreaseNodeGroupsInGlobalReplicationGroupInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDecreaseNodeGroupsInGlobalReplicationGroupInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDecreaseReplicaCount struct {
334}
335
336func (*validateOpDecreaseReplicaCount) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDecreaseReplicaCount) 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.(*DecreaseReplicaCountInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDecreaseReplicaCountInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDeleteCacheCluster struct {
354}
355
356func (*validateOpDeleteCacheCluster) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDeleteCacheCluster) 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.(*DeleteCacheClusterInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDeleteCacheClusterInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDeleteCacheParameterGroup struct {
374}
375
376func (*validateOpDeleteCacheParameterGroup) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDeleteCacheParameterGroup) 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.(*DeleteCacheParameterGroupInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDeleteCacheParameterGroupInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDeleteCacheSecurityGroup struct {
394}
395
396func (*validateOpDeleteCacheSecurityGroup) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDeleteCacheSecurityGroup) 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.(*DeleteCacheSecurityGroupInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDeleteCacheSecurityGroupInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpDeleteCacheSubnetGroup struct {
414}
415
416func (*validateOpDeleteCacheSubnetGroup) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpDeleteCacheSubnetGroup) 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.(*DeleteCacheSubnetGroupInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpDeleteCacheSubnetGroupInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpDeleteGlobalReplicationGroup struct {
434}
435
436func (*validateOpDeleteGlobalReplicationGroup) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpDeleteGlobalReplicationGroup) 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.(*DeleteGlobalReplicationGroupInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpDeleteGlobalReplicationGroupInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpDeleteReplicationGroup struct {
454}
455
456func (*validateOpDeleteReplicationGroup) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpDeleteReplicationGroup) 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.(*DeleteReplicationGroupInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpDeleteReplicationGroupInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpDeleteSnapshot struct {
474}
475
476func (*validateOpDeleteSnapshot) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpDeleteSnapshot) 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.(*DeleteSnapshotInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpDeleteSnapshotInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpDeleteUserGroup struct {
494}
495
496func (*validateOpDeleteUserGroup) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpDeleteUserGroup) 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.(*DeleteUserGroupInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpDeleteUserGroupInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpDeleteUser struct {
514}
515
516func (*validateOpDeleteUser) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpDeleteUser) 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.(*DeleteUserInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpDeleteUserInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpDescribeCacheParameters struct {
534}
535
536func (*validateOpDescribeCacheParameters) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpDescribeCacheParameters) 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.(*DescribeCacheParametersInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpDescribeCacheParametersInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpDescribeEngineDefaultParameters struct {
554}
555
556func (*validateOpDescribeEngineDefaultParameters) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpDescribeEngineDefaultParameters) 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.(*DescribeEngineDefaultParametersInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpDescribeEngineDefaultParametersInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpDescribeUsers struct {
574}
575
576func (*validateOpDescribeUsers) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpDescribeUsers) 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.(*DescribeUsersInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpDescribeUsersInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpDisassociateGlobalReplicationGroup struct {
594}
595
596func (*validateOpDisassociateGlobalReplicationGroup) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpDisassociateGlobalReplicationGroup) 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.(*DisassociateGlobalReplicationGroupInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpDisassociateGlobalReplicationGroupInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpFailoverGlobalReplicationGroup struct {
614}
615
616func (*validateOpFailoverGlobalReplicationGroup) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpFailoverGlobalReplicationGroup) 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.(*FailoverGlobalReplicationGroupInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpFailoverGlobalReplicationGroupInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpIncreaseNodeGroupsInGlobalReplicationGroup struct {
634}
635
636func (*validateOpIncreaseNodeGroupsInGlobalReplicationGroup) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpIncreaseNodeGroupsInGlobalReplicationGroup) 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.(*IncreaseNodeGroupsInGlobalReplicationGroupInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpIncreaseNodeGroupsInGlobalReplicationGroupInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpIncreaseReplicaCount struct {
654}
655
656func (*validateOpIncreaseReplicaCount) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpIncreaseReplicaCount) 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.(*IncreaseReplicaCountInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpIncreaseReplicaCountInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpListTagsForResource struct {
674}
675
676func (*validateOpListTagsForResource) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpListTagsForResourceInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpModifyCacheCluster struct {
694}
695
696func (*validateOpModifyCacheCluster) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpModifyCacheCluster) 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.(*ModifyCacheClusterInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpModifyCacheClusterInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpModifyCacheParameterGroup struct {
714}
715
716func (*validateOpModifyCacheParameterGroup) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpModifyCacheParameterGroup) 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.(*ModifyCacheParameterGroupInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpModifyCacheParameterGroupInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpModifyCacheSubnetGroup struct {
734}
735
736func (*validateOpModifyCacheSubnetGroup) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpModifyCacheSubnetGroup) 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.(*ModifyCacheSubnetGroupInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpModifyCacheSubnetGroupInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpModifyGlobalReplicationGroup struct {
754}
755
756func (*validateOpModifyGlobalReplicationGroup) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpModifyGlobalReplicationGroup) 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.(*ModifyGlobalReplicationGroupInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpModifyGlobalReplicationGroupInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpModifyReplicationGroup struct {
774}
775
776func (*validateOpModifyReplicationGroup) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpModifyReplicationGroup) 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.(*ModifyReplicationGroupInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpModifyReplicationGroupInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpModifyReplicationGroupShardConfiguration struct {
794}
795
796func (*validateOpModifyReplicationGroupShardConfiguration) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpModifyReplicationGroupShardConfiguration) 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.(*ModifyReplicationGroupShardConfigurationInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpModifyReplicationGroupShardConfigurationInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpModifyUserGroup struct {
814}
815
816func (*validateOpModifyUserGroup) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpModifyUserGroup) 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.(*ModifyUserGroupInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpModifyUserGroupInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpModifyUser struct {
834}
835
836func (*validateOpModifyUser) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpModifyUser) 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.(*ModifyUserInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpModifyUserInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpPurchaseReservedCacheNodesOffering struct {
854}
855
856func (*validateOpPurchaseReservedCacheNodesOffering) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpPurchaseReservedCacheNodesOffering) 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.(*PurchaseReservedCacheNodesOfferingInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpPurchaseReservedCacheNodesOfferingInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873type validateOpRebalanceSlotsInGlobalReplicationGroup struct {
874}
875
876func (*validateOpRebalanceSlotsInGlobalReplicationGroup) ID() string {
877	return "OperationInputValidation"
878}
879
880func (m *validateOpRebalanceSlotsInGlobalReplicationGroup) 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.(*RebalanceSlotsInGlobalReplicationGroupInput)
884	if !ok {
885		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
886	}
887	if err := validateOpRebalanceSlotsInGlobalReplicationGroupInput(input); err != nil {
888		return out, metadata, err
889	}
890	return next.HandleInitialize(ctx, in)
891}
892
893type validateOpRebootCacheCluster struct {
894}
895
896func (*validateOpRebootCacheCluster) ID() string {
897	return "OperationInputValidation"
898}
899
900func (m *validateOpRebootCacheCluster) 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.(*RebootCacheClusterInput)
904	if !ok {
905		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
906	}
907	if err := validateOpRebootCacheClusterInput(input); err != nil {
908		return out, metadata, err
909	}
910	return next.HandleInitialize(ctx, in)
911}
912
913type validateOpRemoveTagsFromResource struct {
914}
915
916func (*validateOpRemoveTagsFromResource) ID() string {
917	return "OperationInputValidation"
918}
919
920func (m *validateOpRemoveTagsFromResource) 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.(*RemoveTagsFromResourceInput)
924	if !ok {
925		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
926	}
927	if err := validateOpRemoveTagsFromResourceInput(input); err != nil {
928		return out, metadata, err
929	}
930	return next.HandleInitialize(ctx, in)
931}
932
933type validateOpResetCacheParameterGroup struct {
934}
935
936func (*validateOpResetCacheParameterGroup) ID() string {
937	return "OperationInputValidation"
938}
939
940func (m *validateOpResetCacheParameterGroup) 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.(*ResetCacheParameterGroupInput)
944	if !ok {
945		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
946	}
947	if err := validateOpResetCacheParameterGroupInput(input); err != nil {
948		return out, metadata, err
949	}
950	return next.HandleInitialize(ctx, in)
951}
952
953type validateOpRevokeCacheSecurityGroupIngress struct {
954}
955
956func (*validateOpRevokeCacheSecurityGroupIngress) ID() string {
957	return "OperationInputValidation"
958}
959
960func (m *validateOpRevokeCacheSecurityGroupIngress) 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.(*RevokeCacheSecurityGroupIngressInput)
964	if !ok {
965		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
966	}
967	if err := validateOpRevokeCacheSecurityGroupIngressInput(input); err != nil {
968		return out, metadata, err
969	}
970	return next.HandleInitialize(ctx, in)
971}
972
973type validateOpStartMigration struct {
974}
975
976func (*validateOpStartMigration) ID() string {
977	return "OperationInputValidation"
978}
979
980func (m *validateOpStartMigration) 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.(*StartMigrationInput)
984	if !ok {
985		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
986	}
987	if err := validateOpStartMigrationInput(input); err != nil {
988		return out, metadata, err
989	}
990	return next.HandleInitialize(ctx, in)
991}
992
993type validateOpTestFailover struct {
994}
995
996func (*validateOpTestFailover) ID() string {
997	return "OperationInputValidation"
998}
999
1000func (m *validateOpTestFailover) 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.(*TestFailoverInput)
1004	if !ok {
1005		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
1006	}
1007	if err := validateOpTestFailoverInput(input); err != nil {
1008		return out, metadata, err
1009	}
1010	return next.HandleInitialize(ctx, in)
1011}
1012
1013func addOpAddTagsToResourceValidationMiddleware(stack *middleware.Stack) error {
1014	return stack.Initialize.Add(&validateOpAddTagsToResource{}, middleware.After)
1015}
1016
1017func addOpAuthorizeCacheSecurityGroupIngressValidationMiddleware(stack *middleware.Stack) error {
1018	return stack.Initialize.Add(&validateOpAuthorizeCacheSecurityGroupIngress{}, middleware.After)
1019}
1020
1021func addOpBatchApplyUpdateActionValidationMiddleware(stack *middleware.Stack) error {
1022	return stack.Initialize.Add(&validateOpBatchApplyUpdateAction{}, middleware.After)
1023}
1024
1025func addOpBatchStopUpdateActionValidationMiddleware(stack *middleware.Stack) error {
1026	return stack.Initialize.Add(&validateOpBatchStopUpdateAction{}, middleware.After)
1027}
1028
1029func addOpCompleteMigrationValidationMiddleware(stack *middleware.Stack) error {
1030	return stack.Initialize.Add(&validateOpCompleteMigration{}, middleware.After)
1031}
1032
1033func addOpCopySnapshotValidationMiddleware(stack *middleware.Stack) error {
1034	return stack.Initialize.Add(&validateOpCopySnapshot{}, middleware.After)
1035}
1036
1037func addOpCreateCacheClusterValidationMiddleware(stack *middleware.Stack) error {
1038	return stack.Initialize.Add(&validateOpCreateCacheCluster{}, middleware.After)
1039}
1040
1041func addOpCreateCacheParameterGroupValidationMiddleware(stack *middleware.Stack) error {
1042	return stack.Initialize.Add(&validateOpCreateCacheParameterGroup{}, middleware.After)
1043}
1044
1045func addOpCreateCacheSecurityGroupValidationMiddleware(stack *middleware.Stack) error {
1046	return stack.Initialize.Add(&validateOpCreateCacheSecurityGroup{}, middleware.After)
1047}
1048
1049func addOpCreateCacheSubnetGroupValidationMiddleware(stack *middleware.Stack) error {
1050	return stack.Initialize.Add(&validateOpCreateCacheSubnetGroup{}, middleware.After)
1051}
1052
1053func addOpCreateGlobalReplicationGroupValidationMiddleware(stack *middleware.Stack) error {
1054	return stack.Initialize.Add(&validateOpCreateGlobalReplicationGroup{}, middleware.After)
1055}
1056
1057func addOpCreateReplicationGroupValidationMiddleware(stack *middleware.Stack) error {
1058	return stack.Initialize.Add(&validateOpCreateReplicationGroup{}, middleware.After)
1059}
1060
1061func addOpCreateSnapshotValidationMiddleware(stack *middleware.Stack) error {
1062	return stack.Initialize.Add(&validateOpCreateSnapshot{}, middleware.After)
1063}
1064
1065func addOpCreateUserGroupValidationMiddleware(stack *middleware.Stack) error {
1066	return stack.Initialize.Add(&validateOpCreateUserGroup{}, middleware.After)
1067}
1068
1069func addOpCreateUserValidationMiddleware(stack *middleware.Stack) error {
1070	return stack.Initialize.Add(&validateOpCreateUser{}, middleware.After)
1071}
1072
1073func addOpDecreaseNodeGroupsInGlobalReplicationGroupValidationMiddleware(stack *middleware.Stack) error {
1074	return stack.Initialize.Add(&validateOpDecreaseNodeGroupsInGlobalReplicationGroup{}, middleware.After)
1075}
1076
1077func addOpDecreaseReplicaCountValidationMiddleware(stack *middleware.Stack) error {
1078	return stack.Initialize.Add(&validateOpDecreaseReplicaCount{}, middleware.After)
1079}
1080
1081func addOpDeleteCacheClusterValidationMiddleware(stack *middleware.Stack) error {
1082	return stack.Initialize.Add(&validateOpDeleteCacheCluster{}, middleware.After)
1083}
1084
1085func addOpDeleteCacheParameterGroupValidationMiddleware(stack *middleware.Stack) error {
1086	return stack.Initialize.Add(&validateOpDeleteCacheParameterGroup{}, middleware.After)
1087}
1088
1089func addOpDeleteCacheSecurityGroupValidationMiddleware(stack *middleware.Stack) error {
1090	return stack.Initialize.Add(&validateOpDeleteCacheSecurityGroup{}, middleware.After)
1091}
1092
1093func addOpDeleteCacheSubnetGroupValidationMiddleware(stack *middleware.Stack) error {
1094	return stack.Initialize.Add(&validateOpDeleteCacheSubnetGroup{}, middleware.After)
1095}
1096
1097func addOpDeleteGlobalReplicationGroupValidationMiddleware(stack *middleware.Stack) error {
1098	return stack.Initialize.Add(&validateOpDeleteGlobalReplicationGroup{}, middleware.After)
1099}
1100
1101func addOpDeleteReplicationGroupValidationMiddleware(stack *middleware.Stack) error {
1102	return stack.Initialize.Add(&validateOpDeleteReplicationGroup{}, middleware.After)
1103}
1104
1105func addOpDeleteSnapshotValidationMiddleware(stack *middleware.Stack) error {
1106	return stack.Initialize.Add(&validateOpDeleteSnapshot{}, middleware.After)
1107}
1108
1109func addOpDeleteUserGroupValidationMiddleware(stack *middleware.Stack) error {
1110	return stack.Initialize.Add(&validateOpDeleteUserGroup{}, middleware.After)
1111}
1112
1113func addOpDeleteUserValidationMiddleware(stack *middleware.Stack) error {
1114	return stack.Initialize.Add(&validateOpDeleteUser{}, middleware.After)
1115}
1116
1117func addOpDescribeCacheParametersValidationMiddleware(stack *middleware.Stack) error {
1118	return stack.Initialize.Add(&validateOpDescribeCacheParameters{}, middleware.After)
1119}
1120
1121func addOpDescribeEngineDefaultParametersValidationMiddleware(stack *middleware.Stack) error {
1122	return stack.Initialize.Add(&validateOpDescribeEngineDefaultParameters{}, middleware.After)
1123}
1124
1125func addOpDescribeUsersValidationMiddleware(stack *middleware.Stack) error {
1126	return stack.Initialize.Add(&validateOpDescribeUsers{}, middleware.After)
1127}
1128
1129func addOpDisassociateGlobalReplicationGroupValidationMiddleware(stack *middleware.Stack) error {
1130	return stack.Initialize.Add(&validateOpDisassociateGlobalReplicationGroup{}, middleware.After)
1131}
1132
1133func addOpFailoverGlobalReplicationGroupValidationMiddleware(stack *middleware.Stack) error {
1134	return stack.Initialize.Add(&validateOpFailoverGlobalReplicationGroup{}, middleware.After)
1135}
1136
1137func addOpIncreaseNodeGroupsInGlobalReplicationGroupValidationMiddleware(stack *middleware.Stack) error {
1138	return stack.Initialize.Add(&validateOpIncreaseNodeGroupsInGlobalReplicationGroup{}, middleware.After)
1139}
1140
1141func addOpIncreaseReplicaCountValidationMiddleware(stack *middleware.Stack) error {
1142	return stack.Initialize.Add(&validateOpIncreaseReplicaCount{}, middleware.After)
1143}
1144
1145func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
1146	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
1147}
1148
1149func addOpModifyCacheClusterValidationMiddleware(stack *middleware.Stack) error {
1150	return stack.Initialize.Add(&validateOpModifyCacheCluster{}, middleware.After)
1151}
1152
1153func addOpModifyCacheParameterGroupValidationMiddleware(stack *middleware.Stack) error {
1154	return stack.Initialize.Add(&validateOpModifyCacheParameterGroup{}, middleware.After)
1155}
1156
1157func addOpModifyCacheSubnetGroupValidationMiddleware(stack *middleware.Stack) error {
1158	return stack.Initialize.Add(&validateOpModifyCacheSubnetGroup{}, middleware.After)
1159}
1160
1161func addOpModifyGlobalReplicationGroupValidationMiddleware(stack *middleware.Stack) error {
1162	return stack.Initialize.Add(&validateOpModifyGlobalReplicationGroup{}, middleware.After)
1163}
1164
1165func addOpModifyReplicationGroupValidationMiddleware(stack *middleware.Stack) error {
1166	return stack.Initialize.Add(&validateOpModifyReplicationGroup{}, middleware.After)
1167}
1168
1169func addOpModifyReplicationGroupShardConfigurationValidationMiddleware(stack *middleware.Stack) error {
1170	return stack.Initialize.Add(&validateOpModifyReplicationGroupShardConfiguration{}, middleware.After)
1171}
1172
1173func addOpModifyUserGroupValidationMiddleware(stack *middleware.Stack) error {
1174	return stack.Initialize.Add(&validateOpModifyUserGroup{}, middleware.After)
1175}
1176
1177func addOpModifyUserValidationMiddleware(stack *middleware.Stack) error {
1178	return stack.Initialize.Add(&validateOpModifyUser{}, middleware.After)
1179}
1180
1181func addOpPurchaseReservedCacheNodesOfferingValidationMiddleware(stack *middleware.Stack) error {
1182	return stack.Initialize.Add(&validateOpPurchaseReservedCacheNodesOffering{}, middleware.After)
1183}
1184
1185func addOpRebalanceSlotsInGlobalReplicationGroupValidationMiddleware(stack *middleware.Stack) error {
1186	return stack.Initialize.Add(&validateOpRebalanceSlotsInGlobalReplicationGroup{}, middleware.After)
1187}
1188
1189func addOpRebootCacheClusterValidationMiddleware(stack *middleware.Stack) error {
1190	return stack.Initialize.Add(&validateOpRebootCacheCluster{}, middleware.After)
1191}
1192
1193func addOpRemoveTagsFromResourceValidationMiddleware(stack *middleware.Stack) error {
1194	return stack.Initialize.Add(&validateOpRemoveTagsFromResource{}, middleware.After)
1195}
1196
1197func addOpResetCacheParameterGroupValidationMiddleware(stack *middleware.Stack) error {
1198	return stack.Initialize.Add(&validateOpResetCacheParameterGroup{}, middleware.After)
1199}
1200
1201func addOpRevokeCacheSecurityGroupIngressValidationMiddleware(stack *middleware.Stack) error {
1202	return stack.Initialize.Add(&validateOpRevokeCacheSecurityGroupIngress{}, middleware.After)
1203}
1204
1205func addOpStartMigrationValidationMiddleware(stack *middleware.Stack) error {
1206	return stack.Initialize.Add(&validateOpStartMigration{}, middleware.After)
1207}
1208
1209func addOpTestFailoverValidationMiddleware(stack *middleware.Stack) error {
1210	return stack.Initialize.Add(&validateOpTestFailover{}, middleware.After)
1211}
1212
1213func validateConfigureShard(v *types.ConfigureShard) error {
1214	if v == nil {
1215		return nil
1216	}
1217	invalidParams := smithy.InvalidParamsError{Context: "ConfigureShard"}
1218	if v.NodeGroupId == nil {
1219		invalidParams.Add(smithy.NewErrParamRequired("NodeGroupId"))
1220	}
1221	if invalidParams.Len() > 0 {
1222		return invalidParams
1223	} else {
1224		return nil
1225	}
1226}
1227
1228func validateFilter(v *types.Filter) error {
1229	if v == nil {
1230		return nil
1231	}
1232	invalidParams := smithy.InvalidParamsError{Context: "Filter"}
1233	if v.Name == nil {
1234		invalidParams.Add(smithy.NewErrParamRequired("Name"))
1235	}
1236	if v.Values == nil {
1237		invalidParams.Add(smithy.NewErrParamRequired("Values"))
1238	}
1239	if invalidParams.Len() > 0 {
1240		return invalidParams
1241	} else {
1242		return nil
1243	}
1244}
1245
1246func validateFilterList(v []types.Filter) error {
1247	if v == nil {
1248		return nil
1249	}
1250	invalidParams := smithy.InvalidParamsError{Context: "FilterList"}
1251	for i := range v {
1252		if err := validateFilter(&v[i]); err != nil {
1253			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1254		}
1255	}
1256	if invalidParams.Len() > 0 {
1257		return invalidParams
1258	} else {
1259		return nil
1260	}
1261}
1262
1263func validateRegionalConfiguration(v *types.RegionalConfiguration) error {
1264	if v == nil {
1265		return nil
1266	}
1267	invalidParams := smithy.InvalidParamsError{Context: "RegionalConfiguration"}
1268	if v.ReplicationGroupId == nil {
1269		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
1270	}
1271	if v.ReplicationGroupRegion == nil {
1272		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupRegion"))
1273	}
1274	if v.ReshardingConfiguration == nil {
1275		invalidParams.Add(smithy.NewErrParamRequired("ReshardingConfiguration"))
1276	}
1277	if invalidParams.Len() > 0 {
1278		return invalidParams
1279	} else {
1280		return nil
1281	}
1282}
1283
1284func validateRegionalConfigurationList(v []types.RegionalConfiguration) error {
1285	if v == nil {
1286		return nil
1287	}
1288	invalidParams := smithy.InvalidParamsError{Context: "RegionalConfigurationList"}
1289	for i := range v {
1290		if err := validateRegionalConfiguration(&v[i]); err != nil {
1291			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1292		}
1293	}
1294	if invalidParams.Len() > 0 {
1295		return invalidParams
1296	} else {
1297		return nil
1298	}
1299}
1300
1301func validateReplicaConfigurationList(v []types.ConfigureShard) error {
1302	if v == nil {
1303		return nil
1304	}
1305	invalidParams := smithy.InvalidParamsError{Context: "ReplicaConfigurationList"}
1306	for i := range v {
1307		if err := validateConfigureShard(&v[i]); err != nil {
1308			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1309		}
1310	}
1311	if invalidParams.Len() > 0 {
1312		return invalidParams
1313	} else {
1314		return nil
1315	}
1316}
1317
1318func validateOpAddTagsToResourceInput(v *AddTagsToResourceInput) error {
1319	if v == nil {
1320		return nil
1321	}
1322	invalidParams := smithy.InvalidParamsError{Context: "AddTagsToResourceInput"}
1323	if v.ResourceName == nil {
1324		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
1325	}
1326	if v.Tags == nil {
1327		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
1328	}
1329	if invalidParams.Len() > 0 {
1330		return invalidParams
1331	} else {
1332		return nil
1333	}
1334}
1335
1336func validateOpAuthorizeCacheSecurityGroupIngressInput(v *AuthorizeCacheSecurityGroupIngressInput) error {
1337	if v == nil {
1338		return nil
1339	}
1340	invalidParams := smithy.InvalidParamsError{Context: "AuthorizeCacheSecurityGroupIngressInput"}
1341	if v.CacheSecurityGroupName == nil {
1342		invalidParams.Add(smithy.NewErrParamRequired("CacheSecurityGroupName"))
1343	}
1344	if v.EC2SecurityGroupName == nil {
1345		invalidParams.Add(smithy.NewErrParamRequired("EC2SecurityGroupName"))
1346	}
1347	if v.EC2SecurityGroupOwnerId == nil {
1348		invalidParams.Add(smithy.NewErrParamRequired("EC2SecurityGroupOwnerId"))
1349	}
1350	if invalidParams.Len() > 0 {
1351		return invalidParams
1352	} else {
1353		return nil
1354	}
1355}
1356
1357func validateOpBatchApplyUpdateActionInput(v *BatchApplyUpdateActionInput) error {
1358	if v == nil {
1359		return nil
1360	}
1361	invalidParams := smithy.InvalidParamsError{Context: "BatchApplyUpdateActionInput"}
1362	if v.ServiceUpdateName == nil {
1363		invalidParams.Add(smithy.NewErrParamRequired("ServiceUpdateName"))
1364	}
1365	if invalidParams.Len() > 0 {
1366		return invalidParams
1367	} else {
1368		return nil
1369	}
1370}
1371
1372func validateOpBatchStopUpdateActionInput(v *BatchStopUpdateActionInput) error {
1373	if v == nil {
1374		return nil
1375	}
1376	invalidParams := smithy.InvalidParamsError{Context: "BatchStopUpdateActionInput"}
1377	if v.ServiceUpdateName == nil {
1378		invalidParams.Add(smithy.NewErrParamRequired("ServiceUpdateName"))
1379	}
1380	if invalidParams.Len() > 0 {
1381		return invalidParams
1382	} else {
1383		return nil
1384	}
1385}
1386
1387func validateOpCompleteMigrationInput(v *CompleteMigrationInput) error {
1388	if v == nil {
1389		return nil
1390	}
1391	invalidParams := smithy.InvalidParamsError{Context: "CompleteMigrationInput"}
1392	if v.ReplicationGroupId == nil {
1393		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
1394	}
1395	if invalidParams.Len() > 0 {
1396		return invalidParams
1397	} else {
1398		return nil
1399	}
1400}
1401
1402func validateOpCopySnapshotInput(v *CopySnapshotInput) error {
1403	if v == nil {
1404		return nil
1405	}
1406	invalidParams := smithy.InvalidParamsError{Context: "CopySnapshotInput"}
1407	if v.SourceSnapshotName == nil {
1408		invalidParams.Add(smithy.NewErrParamRequired("SourceSnapshotName"))
1409	}
1410	if v.TargetSnapshotName == nil {
1411		invalidParams.Add(smithy.NewErrParamRequired("TargetSnapshotName"))
1412	}
1413	if invalidParams.Len() > 0 {
1414		return invalidParams
1415	} else {
1416		return nil
1417	}
1418}
1419
1420func validateOpCreateCacheClusterInput(v *CreateCacheClusterInput) error {
1421	if v == nil {
1422		return nil
1423	}
1424	invalidParams := smithy.InvalidParamsError{Context: "CreateCacheClusterInput"}
1425	if v.CacheClusterId == nil {
1426		invalidParams.Add(smithy.NewErrParamRequired("CacheClusterId"))
1427	}
1428	if invalidParams.Len() > 0 {
1429		return invalidParams
1430	} else {
1431		return nil
1432	}
1433}
1434
1435func validateOpCreateCacheParameterGroupInput(v *CreateCacheParameterGroupInput) error {
1436	if v == nil {
1437		return nil
1438	}
1439	invalidParams := smithy.InvalidParamsError{Context: "CreateCacheParameterGroupInput"}
1440	if v.CacheParameterGroupName == nil {
1441		invalidParams.Add(smithy.NewErrParamRequired("CacheParameterGroupName"))
1442	}
1443	if v.CacheParameterGroupFamily == nil {
1444		invalidParams.Add(smithy.NewErrParamRequired("CacheParameterGroupFamily"))
1445	}
1446	if v.Description == nil {
1447		invalidParams.Add(smithy.NewErrParamRequired("Description"))
1448	}
1449	if invalidParams.Len() > 0 {
1450		return invalidParams
1451	} else {
1452		return nil
1453	}
1454}
1455
1456func validateOpCreateCacheSecurityGroupInput(v *CreateCacheSecurityGroupInput) error {
1457	if v == nil {
1458		return nil
1459	}
1460	invalidParams := smithy.InvalidParamsError{Context: "CreateCacheSecurityGroupInput"}
1461	if v.CacheSecurityGroupName == nil {
1462		invalidParams.Add(smithy.NewErrParamRequired("CacheSecurityGroupName"))
1463	}
1464	if v.Description == nil {
1465		invalidParams.Add(smithy.NewErrParamRequired("Description"))
1466	}
1467	if invalidParams.Len() > 0 {
1468		return invalidParams
1469	} else {
1470		return nil
1471	}
1472}
1473
1474func validateOpCreateCacheSubnetGroupInput(v *CreateCacheSubnetGroupInput) error {
1475	if v == nil {
1476		return nil
1477	}
1478	invalidParams := smithy.InvalidParamsError{Context: "CreateCacheSubnetGroupInput"}
1479	if v.CacheSubnetGroupName == nil {
1480		invalidParams.Add(smithy.NewErrParamRequired("CacheSubnetGroupName"))
1481	}
1482	if v.CacheSubnetGroupDescription == nil {
1483		invalidParams.Add(smithy.NewErrParamRequired("CacheSubnetGroupDescription"))
1484	}
1485	if v.SubnetIds == nil {
1486		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
1487	}
1488	if invalidParams.Len() > 0 {
1489		return invalidParams
1490	} else {
1491		return nil
1492	}
1493}
1494
1495func validateOpCreateGlobalReplicationGroupInput(v *CreateGlobalReplicationGroupInput) error {
1496	if v == nil {
1497		return nil
1498	}
1499	invalidParams := smithy.InvalidParamsError{Context: "CreateGlobalReplicationGroupInput"}
1500	if v.GlobalReplicationGroupIdSuffix == nil {
1501		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupIdSuffix"))
1502	}
1503	if v.PrimaryReplicationGroupId == nil {
1504		invalidParams.Add(smithy.NewErrParamRequired("PrimaryReplicationGroupId"))
1505	}
1506	if invalidParams.Len() > 0 {
1507		return invalidParams
1508	} else {
1509		return nil
1510	}
1511}
1512
1513func validateOpCreateReplicationGroupInput(v *CreateReplicationGroupInput) error {
1514	if v == nil {
1515		return nil
1516	}
1517	invalidParams := smithy.InvalidParamsError{Context: "CreateReplicationGroupInput"}
1518	if v.ReplicationGroupId == nil {
1519		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
1520	}
1521	if v.ReplicationGroupDescription == nil {
1522		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupDescription"))
1523	}
1524	if invalidParams.Len() > 0 {
1525		return invalidParams
1526	} else {
1527		return nil
1528	}
1529}
1530
1531func validateOpCreateSnapshotInput(v *CreateSnapshotInput) error {
1532	if v == nil {
1533		return nil
1534	}
1535	invalidParams := smithy.InvalidParamsError{Context: "CreateSnapshotInput"}
1536	if v.SnapshotName == nil {
1537		invalidParams.Add(smithy.NewErrParamRequired("SnapshotName"))
1538	}
1539	if invalidParams.Len() > 0 {
1540		return invalidParams
1541	} else {
1542		return nil
1543	}
1544}
1545
1546func validateOpCreateUserGroupInput(v *CreateUserGroupInput) error {
1547	if v == nil {
1548		return nil
1549	}
1550	invalidParams := smithy.InvalidParamsError{Context: "CreateUserGroupInput"}
1551	if v.UserGroupId == nil {
1552		invalidParams.Add(smithy.NewErrParamRequired("UserGroupId"))
1553	}
1554	if v.Engine == nil {
1555		invalidParams.Add(smithy.NewErrParamRequired("Engine"))
1556	}
1557	if invalidParams.Len() > 0 {
1558		return invalidParams
1559	} else {
1560		return nil
1561	}
1562}
1563
1564func validateOpCreateUserInput(v *CreateUserInput) error {
1565	if v == nil {
1566		return nil
1567	}
1568	invalidParams := smithy.InvalidParamsError{Context: "CreateUserInput"}
1569	if v.UserId == nil {
1570		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
1571	}
1572	if v.UserName == nil {
1573		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
1574	}
1575	if v.Engine == nil {
1576		invalidParams.Add(smithy.NewErrParamRequired("Engine"))
1577	}
1578	if v.AccessString == nil {
1579		invalidParams.Add(smithy.NewErrParamRequired("AccessString"))
1580	}
1581	if invalidParams.Len() > 0 {
1582		return invalidParams
1583	} else {
1584		return nil
1585	}
1586}
1587
1588func validateOpDecreaseNodeGroupsInGlobalReplicationGroupInput(v *DecreaseNodeGroupsInGlobalReplicationGroupInput) error {
1589	if v == nil {
1590		return nil
1591	}
1592	invalidParams := smithy.InvalidParamsError{Context: "DecreaseNodeGroupsInGlobalReplicationGroupInput"}
1593	if v.GlobalReplicationGroupId == nil {
1594		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupId"))
1595	}
1596	if invalidParams.Len() > 0 {
1597		return invalidParams
1598	} else {
1599		return nil
1600	}
1601}
1602
1603func validateOpDecreaseReplicaCountInput(v *DecreaseReplicaCountInput) error {
1604	if v == nil {
1605		return nil
1606	}
1607	invalidParams := smithy.InvalidParamsError{Context: "DecreaseReplicaCountInput"}
1608	if v.ReplicationGroupId == nil {
1609		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
1610	}
1611	if v.ReplicaConfiguration != nil {
1612		if err := validateReplicaConfigurationList(v.ReplicaConfiguration); err != nil {
1613			invalidParams.AddNested("ReplicaConfiguration", err.(smithy.InvalidParamsError))
1614		}
1615	}
1616	if invalidParams.Len() > 0 {
1617		return invalidParams
1618	} else {
1619		return nil
1620	}
1621}
1622
1623func validateOpDeleteCacheClusterInput(v *DeleteCacheClusterInput) error {
1624	if v == nil {
1625		return nil
1626	}
1627	invalidParams := smithy.InvalidParamsError{Context: "DeleteCacheClusterInput"}
1628	if v.CacheClusterId == nil {
1629		invalidParams.Add(smithy.NewErrParamRequired("CacheClusterId"))
1630	}
1631	if invalidParams.Len() > 0 {
1632		return invalidParams
1633	} else {
1634		return nil
1635	}
1636}
1637
1638func validateOpDeleteCacheParameterGroupInput(v *DeleteCacheParameterGroupInput) error {
1639	if v == nil {
1640		return nil
1641	}
1642	invalidParams := smithy.InvalidParamsError{Context: "DeleteCacheParameterGroupInput"}
1643	if v.CacheParameterGroupName == nil {
1644		invalidParams.Add(smithy.NewErrParamRequired("CacheParameterGroupName"))
1645	}
1646	if invalidParams.Len() > 0 {
1647		return invalidParams
1648	} else {
1649		return nil
1650	}
1651}
1652
1653func validateOpDeleteCacheSecurityGroupInput(v *DeleteCacheSecurityGroupInput) error {
1654	if v == nil {
1655		return nil
1656	}
1657	invalidParams := smithy.InvalidParamsError{Context: "DeleteCacheSecurityGroupInput"}
1658	if v.CacheSecurityGroupName == nil {
1659		invalidParams.Add(smithy.NewErrParamRequired("CacheSecurityGroupName"))
1660	}
1661	if invalidParams.Len() > 0 {
1662		return invalidParams
1663	} else {
1664		return nil
1665	}
1666}
1667
1668func validateOpDeleteCacheSubnetGroupInput(v *DeleteCacheSubnetGroupInput) error {
1669	if v == nil {
1670		return nil
1671	}
1672	invalidParams := smithy.InvalidParamsError{Context: "DeleteCacheSubnetGroupInput"}
1673	if v.CacheSubnetGroupName == nil {
1674		invalidParams.Add(smithy.NewErrParamRequired("CacheSubnetGroupName"))
1675	}
1676	if invalidParams.Len() > 0 {
1677		return invalidParams
1678	} else {
1679		return nil
1680	}
1681}
1682
1683func validateOpDeleteGlobalReplicationGroupInput(v *DeleteGlobalReplicationGroupInput) error {
1684	if v == nil {
1685		return nil
1686	}
1687	invalidParams := smithy.InvalidParamsError{Context: "DeleteGlobalReplicationGroupInput"}
1688	if v.GlobalReplicationGroupId == nil {
1689		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupId"))
1690	}
1691	if invalidParams.Len() > 0 {
1692		return invalidParams
1693	} else {
1694		return nil
1695	}
1696}
1697
1698func validateOpDeleteReplicationGroupInput(v *DeleteReplicationGroupInput) error {
1699	if v == nil {
1700		return nil
1701	}
1702	invalidParams := smithy.InvalidParamsError{Context: "DeleteReplicationGroupInput"}
1703	if v.ReplicationGroupId == nil {
1704		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
1705	}
1706	if invalidParams.Len() > 0 {
1707		return invalidParams
1708	} else {
1709		return nil
1710	}
1711}
1712
1713func validateOpDeleteSnapshotInput(v *DeleteSnapshotInput) error {
1714	if v == nil {
1715		return nil
1716	}
1717	invalidParams := smithy.InvalidParamsError{Context: "DeleteSnapshotInput"}
1718	if v.SnapshotName == nil {
1719		invalidParams.Add(smithy.NewErrParamRequired("SnapshotName"))
1720	}
1721	if invalidParams.Len() > 0 {
1722		return invalidParams
1723	} else {
1724		return nil
1725	}
1726}
1727
1728func validateOpDeleteUserGroupInput(v *DeleteUserGroupInput) error {
1729	if v == nil {
1730		return nil
1731	}
1732	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserGroupInput"}
1733	if v.UserGroupId == nil {
1734		invalidParams.Add(smithy.NewErrParamRequired("UserGroupId"))
1735	}
1736	if invalidParams.Len() > 0 {
1737		return invalidParams
1738	} else {
1739		return nil
1740	}
1741}
1742
1743func validateOpDeleteUserInput(v *DeleteUserInput) error {
1744	if v == nil {
1745		return nil
1746	}
1747	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserInput"}
1748	if v.UserId == nil {
1749		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
1750	}
1751	if invalidParams.Len() > 0 {
1752		return invalidParams
1753	} else {
1754		return nil
1755	}
1756}
1757
1758func validateOpDescribeCacheParametersInput(v *DescribeCacheParametersInput) error {
1759	if v == nil {
1760		return nil
1761	}
1762	invalidParams := smithy.InvalidParamsError{Context: "DescribeCacheParametersInput"}
1763	if v.CacheParameterGroupName == nil {
1764		invalidParams.Add(smithy.NewErrParamRequired("CacheParameterGroupName"))
1765	}
1766	if invalidParams.Len() > 0 {
1767		return invalidParams
1768	} else {
1769		return nil
1770	}
1771}
1772
1773func validateOpDescribeEngineDefaultParametersInput(v *DescribeEngineDefaultParametersInput) error {
1774	if v == nil {
1775		return nil
1776	}
1777	invalidParams := smithy.InvalidParamsError{Context: "DescribeEngineDefaultParametersInput"}
1778	if v.CacheParameterGroupFamily == nil {
1779		invalidParams.Add(smithy.NewErrParamRequired("CacheParameterGroupFamily"))
1780	}
1781	if invalidParams.Len() > 0 {
1782		return invalidParams
1783	} else {
1784		return nil
1785	}
1786}
1787
1788func validateOpDescribeUsersInput(v *DescribeUsersInput) error {
1789	if v == nil {
1790		return nil
1791	}
1792	invalidParams := smithy.InvalidParamsError{Context: "DescribeUsersInput"}
1793	if v.Filters != nil {
1794		if err := validateFilterList(v.Filters); err != nil {
1795			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
1796		}
1797	}
1798	if invalidParams.Len() > 0 {
1799		return invalidParams
1800	} else {
1801		return nil
1802	}
1803}
1804
1805func validateOpDisassociateGlobalReplicationGroupInput(v *DisassociateGlobalReplicationGroupInput) error {
1806	if v == nil {
1807		return nil
1808	}
1809	invalidParams := smithy.InvalidParamsError{Context: "DisassociateGlobalReplicationGroupInput"}
1810	if v.GlobalReplicationGroupId == nil {
1811		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupId"))
1812	}
1813	if v.ReplicationGroupId == nil {
1814		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
1815	}
1816	if v.ReplicationGroupRegion == nil {
1817		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupRegion"))
1818	}
1819	if invalidParams.Len() > 0 {
1820		return invalidParams
1821	} else {
1822		return nil
1823	}
1824}
1825
1826func validateOpFailoverGlobalReplicationGroupInput(v *FailoverGlobalReplicationGroupInput) error {
1827	if v == nil {
1828		return nil
1829	}
1830	invalidParams := smithy.InvalidParamsError{Context: "FailoverGlobalReplicationGroupInput"}
1831	if v.GlobalReplicationGroupId == nil {
1832		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupId"))
1833	}
1834	if v.PrimaryRegion == nil {
1835		invalidParams.Add(smithy.NewErrParamRequired("PrimaryRegion"))
1836	}
1837	if v.PrimaryReplicationGroupId == nil {
1838		invalidParams.Add(smithy.NewErrParamRequired("PrimaryReplicationGroupId"))
1839	}
1840	if invalidParams.Len() > 0 {
1841		return invalidParams
1842	} else {
1843		return nil
1844	}
1845}
1846
1847func validateOpIncreaseNodeGroupsInGlobalReplicationGroupInput(v *IncreaseNodeGroupsInGlobalReplicationGroupInput) error {
1848	if v == nil {
1849		return nil
1850	}
1851	invalidParams := smithy.InvalidParamsError{Context: "IncreaseNodeGroupsInGlobalReplicationGroupInput"}
1852	if v.GlobalReplicationGroupId == nil {
1853		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupId"))
1854	}
1855	if v.RegionalConfigurations != nil {
1856		if err := validateRegionalConfigurationList(v.RegionalConfigurations); err != nil {
1857			invalidParams.AddNested("RegionalConfigurations", err.(smithy.InvalidParamsError))
1858		}
1859	}
1860	if invalidParams.Len() > 0 {
1861		return invalidParams
1862	} else {
1863		return nil
1864	}
1865}
1866
1867func validateOpIncreaseReplicaCountInput(v *IncreaseReplicaCountInput) error {
1868	if v == nil {
1869		return nil
1870	}
1871	invalidParams := smithy.InvalidParamsError{Context: "IncreaseReplicaCountInput"}
1872	if v.ReplicationGroupId == nil {
1873		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
1874	}
1875	if v.ReplicaConfiguration != nil {
1876		if err := validateReplicaConfigurationList(v.ReplicaConfiguration); err != nil {
1877			invalidParams.AddNested("ReplicaConfiguration", err.(smithy.InvalidParamsError))
1878		}
1879	}
1880	if invalidParams.Len() > 0 {
1881		return invalidParams
1882	} else {
1883		return nil
1884	}
1885}
1886
1887func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
1888	if v == nil {
1889		return nil
1890	}
1891	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
1892	if v.ResourceName == nil {
1893		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
1894	}
1895	if invalidParams.Len() > 0 {
1896		return invalidParams
1897	} else {
1898		return nil
1899	}
1900}
1901
1902func validateOpModifyCacheClusterInput(v *ModifyCacheClusterInput) error {
1903	if v == nil {
1904		return nil
1905	}
1906	invalidParams := smithy.InvalidParamsError{Context: "ModifyCacheClusterInput"}
1907	if v.CacheClusterId == nil {
1908		invalidParams.Add(smithy.NewErrParamRequired("CacheClusterId"))
1909	}
1910	if invalidParams.Len() > 0 {
1911		return invalidParams
1912	} else {
1913		return nil
1914	}
1915}
1916
1917func validateOpModifyCacheParameterGroupInput(v *ModifyCacheParameterGroupInput) error {
1918	if v == nil {
1919		return nil
1920	}
1921	invalidParams := smithy.InvalidParamsError{Context: "ModifyCacheParameterGroupInput"}
1922	if v.CacheParameterGroupName == nil {
1923		invalidParams.Add(smithy.NewErrParamRequired("CacheParameterGroupName"))
1924	}
1925	if v.ParameterNameValues == nil {
1926		invalidParams.Add(smithy.NewErrParamRequired("ParameterNameValues"))
1927	}
1928	if invalidParams.Len() > 0 {
1929		return invalidParams
1930	} else {
1931		return nil
1932	}
1933}
1934
1935func validateOpModifyCacheSubnetGroupInput(v *ModifyCacheSubnetGroupInput) error {
1936	if v == nil {
1937		return nil
1938	}
1939	invalidParams := smithy.InvalidParamsError{Context: "ModifyCacheSubnetGroupInput"}
1940	if v.CacheSubnetGroupName == nil {
1941		invalidParams.Add(smithy.NewErrParamRequired("CacheSubnetGroupName"))
1942	}
1943	if invalidParams.Len() > 0 {
1944		return invalidParams
1945	} else {
1946		return nil
1947	}
1948}
1949
1950func validateOpModifyGlobalReplicationGroupInput(v *ModifyGlobalReplicationGroupInput) error {
1951	if v == nil {
1952		return nil
1953	}
1954	invalidParams := smithy.InvalidParamsError{Context: "ModifyGlobalReplicationGroupInput"}
1955	if v.GlobalReplicationGroupId == nil {
1956		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupId"))
1957	}
1958	if invalidParams.Len() > 0 {
1959		return invalidParams
1960	} else {
1961		return nil
1962	}
1963}
1964
1965func validateOpModifyReplicationGroupInput(v *ModifyReplicationGroupInput) error {
1966	if v == nil {
1967		return nil
1968	}
1969	invalidParams := smithy.InvalidParamsError{Context: "ModifyReplicationGroupInput"}
1970	if v.ReplicationGroupId == nil {
1971		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
1972	}
1973	if invalidParams.Len() > 0 {
1974		return invalidParams
1975	} else {
1976		return nil
1977	}
1978}
1979
1980func validateOpModifyReplicationGroupShardConfigurationInput(v *ModifyReplicationGroupShardConfigurationInput) error {
1981	if v == nil {
1982		return nil
1983	}
1984	invalidParams := smithy.InvalidParamsError{Context: "ModifyReplicationGroupShardConfigurationInput"}
1985	if v.ReplicationGroupId == nil {
1986		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
1987	}
1988	if invalidParams.Len() > 0 {
1989		return invalidParams
1990	} else {
1991		return nil
1992	}
1993}
1994
1995func validateOpModifyUserGroupInput(v *ModifyUserGroupInput) error {
1996	if v == nil {
1997		return nil
1998	}
1999	invalidParams := smithy.InvalidParamsError{Context: "ModifyUserGroupInput"}
2000	if v.UserGroupId == nil {
2001		invalidParams.Add(smithy.NewErrParamRequired("UserGroupId"))
2002	}
2003	if invalidParams.Len() > 0 {
2004		return invalidParams
2005	} else {
2006		return nil
2007	}
2008}
2009
2010func validateOpModifyUserInput(v *ModifyUserInput) error {
2011	if v == nil {
2012		return nil
2013	}
2014	invalidParams := smithy.InvalidParamsError{Context: "ModifyUserInput"}
2015	if v.UserId == nil {
2016		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
2017	}
2018	if invalidParams.Len() > 0 {
2019		return invalidParams
2020	} else {
2021		return nil
2022	}
2023}
2024
2025func validateOpPurchaseReservedCacheNodesOfferingInput(v *PurchaseReservedCacheNodesOfferingInput) error {
2026	if v == nil {
2027		return nil
2028	}
2029	invalidParams := smithy.InvalidParamsError{Context: "PurchaseReservedCacheNodesOfferingInput"}
2030	if v.ReservedCacheNodesOfferingId == nil {
2031		invalidParams.Add(smithy.NewErrParamRequired("ReservedCacheNodesOfferingId"))
2032	}
2033	if invalidParams.Len() > 0 {
2034		return invalidParams
2035	} else {
2036		return nil
2037	}
2038}
2039
2040func validateOpRebalanceSlotsInGlobalReplicationGroupInput(v *RebalanceSlotsInGlobalReplicationGroupInput) error {
2041	if v == nil {
2042		return nil
2043	}
2044	invalidParams := smithy.InvalidParamsError{Context: "RebalanceSlotsInGlobalReplicationGroupInput"}
2045	if v.GlobalReplicationGroupId == nil {
2046		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupId"))
2047	}
2048	if invalidParams.Len() > 0 {
2049		return invalidParams
2050	} else {
2051		return nil
2052	}
2053}
2054
2055func validateOpRebootCacheClusterInput(v *RebootCacheClusterInput) error {
2056	if v == nil {
2057		return nil
2058	}
2059	invalidParams := smithy.InvalidParamsError{Context: "RebootCacheClusterInput"}
2060	if v.CacheClusterId == nil {
2061		invalidParams.Add(smithy.NewErrParamRequired("CacheClusterId"))
2062	}
2063	if v.CacheNodeIdsToReboot == nil {
2064		invalidParams.Add(smithy.NewErrParamRequired("CacheNodeIdsToReboot"))
2065	}
2066	if invalidParams.Len() > 0 {
2067		return invalidParams
2068	} else {
2069		return nil
2070	}
2071}
2072
2073func validateOpRemoveTagsFromResourceInput(v *RemoveTagsFromResourceInput) error {
2074	if v == nil {
2075		return nil
2076	}
2077	invalidParams := smithy.InvalidParamsError{Context: "RemoveTagsFromResourceInput"}
2078	if v.ResourceName == nil {
2079		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
2080	}
2081	if v.TagKeys == nil {
2082		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
2083	}
2084	if invalidParams.Len() > 0 {
2085		return invalidParams
2086	} else {
2087		return nil
2088	}
2089}
2090
2091func validateOpResetCacheParameterGroupInput(v *ResetCacheParameterGroupInput) error {
2092	if v == nil {
2093		return nil
2094	}
2095	invalidParams := smithy.InvalidParamsError{Context: "ResetCacheParameterGroupInput"}
2096	if v.CacheParameterGroupName == nil {
2097		invalidParams.Add(smithy.NewErrParamRequired("CacheParameterGroupName"))
2098	}
2099	if invalidParams.Len() > 0 {
2100		return invalidParams
2101	} else {
2102		return nil
2103	}
2104}
2105
2106func validateOpRevokeCacheSecurityGroupIngressInput(v *RevokeCacheSecurityGroupIngressInput) error {
2107	if v == nil {
2108		return nil
2109	}
2110	invalidParams := smithy.InvalidParamsError{Context: "RevokeCacheSecurityGroupIngressInput"}
2111	if v.CacheSecurityGroupName == nil {
2112		invalidParams.Add(smithy.NewErrParamRequired("CacheSecurityGroupName"))
2113	}
2114	if v.EC2SecurityGroupName == nil {
2115		invalidParams.Add(smithy.NewErrParamRequired("EC2SecurityGroupName"))
2116	}
2117	if v.EC2SecurityGroupOwnerId == nil {
2118		invalidParams.Add(smithy.NewErrParamRequired("EC2SecurityGroupOwnerId"))
2119	}
2120	if invalidParams.Len() > 0 {
2121		return invalidParams
2122	} else {
2123		return nil
2124	}
2125}
2126
2127func validateOpStartMigrationInput(v *StartMigrationInput) error {
2128	if v == nil {
2129		return nil
2130	}
2131	invalidParams := smithy.InvalidParamsError{Context: "StartMigrationInput"}
2132	if v.ReplicationGroupId == nil {
2133		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
2134	}
2135	if v.CustomerNodeEndpointList == nil {
2136		invalidParams.Add(smithy.NewErrParamRequired("CustomerNodeEndpointList"))
2137	}
2138	if invalidParams.Len() > 0 {
2139		return invalidParams
2140	} else {
2141		return nil
2142	}
2143}
2144
2145func validateOpTestFailoverInput(v *TestFailoverInput) error {
2146	if v == nil {
2147		return nil
2148	}
2149	invalidParams := smithy.InvalidParamsError{Context: "TestFailoverInput"}
2150	if v.ReplicationGroupId == nil {
2151		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
2152	}
2153	if v.NodeGroupId == nil {
2154		invalidParams.Add(smithy.NewErrParamRequired("NodeGroupId"))
2155	}
2156	if invalidParams.Len() > 0 {
2157		return invalidParams
2158	} else {
2159		return nil
2160	}
2161}
2162