1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package dynamodb
4
5import (
6	"context"
7	"fmt"
8	"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
9	smithy "github.com/aws/smithy-go"
10	"github.com/aws/smithy-go/middleware"
11)
12
13type validateOpBatchExecuteStatement struct {
14}
15
16func (*validateOpBatchExecuteStatement) ID() string {
17	return "OperationInputValidation"
18}
19
20func (m *validateOpBatchExecuteStatement) 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.(*BatchExecuteStatementInput)
24	if !ok {
25		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
26	}
27	if err := validateOpBatchExecuteStatementInput(input); err != nil {
28		return out, metadata, err
29	}
30	return next.HandleInitialize(ctx, in)
31}
32
33type validateOpBatchGetItem struct {
34}
35
36func (*validateOpBatchGetItem) ID() string {
37	return "OperationInputValidation"
38}
39
40func (m *validateOpBatchGetItem) 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.(*BatchGetItemInput)
44	if !ok {
45		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
46	}
47	if err := validateOpBatchGetItemInput(input); err != nil {
48		return out, metadata, err
49	}
50	return next.HandleInitialize(ctx, in)
51}
52
53type validateOpBatchWriteItem struct {
54}
55
56func (*validateOpBatchWriteItem) ID() string {
57	return "OperationInputValidation"
58}
59
60func (m *validateOpBatchWriteItem) 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.(*BatchWriteItemInput)
64	if !ok {
65		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
66	}
67	if err := validateOpBatchWriteItemInput(input); err != nil {
68		return out, metadata, err
69	}
70	return next.HandleInitialize(ctx, in)
71}
72
73type validateOpCreateBackup struct {
74}
75
76func (*validateOpCreateBackup) ID() string {
77	return "OperationInputValidation"
78}
79
80func (m *validateOpCreateBackup) 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.(*CreateBackupInput)
84	if !ok {
85		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
86	}
87	if err := validateOpCreateBackupInput(input); err != nil {
88		return out, metadata, err
89	}
90	return next.HandleInitialize(ctx, in)
91}
92
93type validateOpCreateGlobalTable struct {
94}
95
96func (*validateOpCreateGlobalTable) ID() string {
97	return "OperationInputValidation"
98}
99
100func (m *validateOpCreateGlobalTable) 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.(*CreateGlobalTableInput)
104	if !ok {
105		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
106	}
107	if err := validateOpCreateGlobalTableInput(input); err != nil {
108		return out, metadata, err
109	}
110	return next.HandleInitialize(ctx, in)
111}
112
113type validateOpCreateTable struct {
114}
115
116func (*validateOpCreateTable) ID() string {
117	return "OperationInputValidation"
118}
119
120func (m *validateOpCreateTable) 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.(*CreateTableInput)
124	if !ok {
125		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
126	}
127	if err := validateOpCreateTableInput(input); err != nil {
128		return out, metadata, err
129	}
130	return next.HandleInitialize(ctx, in)
131}
132
133type validateOpDeleteBackup struct {
134}
135
136func (*validateOpDeleteBackup) ID() string {
137	return "OperationInputValidation"
138}
139
140func (m *validateOpDeleteBackup) 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.(*DeleteBackupInput)
144	if !ok {
145		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
146	}
147	if err := validateOpDeleteBackupInput(input); err != nil {
148		return out, metadata, err
149	}
150	return next.HandleInitialize(ctx, in)
151}
152
153type validateOpDeleteItem struct {
154}
155
156func (*validateOpDeleteItem) ID() string {
157	return "OperationInputValidation"
158}
159
160func (m *validateOpDeleteItem) 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.(*DeleteItemInput)
164	if !ok {
165		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
166	}
167	if err := validateOpDeleteItemInput(input); err != nil {
168		return out, metadata, err
169	}
170	return next.HandleInitialize(ctx, in)
171}
172
173type validateOpDeleteTable struct {
174}
175
176func (*validateOpDeleteTable) ID() string {
177	return "OperationInputValidation"
178}
179
180func (m *validateOpDeleteTable) 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.(*DeleteTableInput)
184	if !ok {
185		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
186	}
187	if err := validateOpDeleteTableInput(input); err != nil {
188		return out, metadata, err
189	}
190	return next.HandleInitialize(ctx, in)
191}
192
193type validateOpDescribeBackup struct {
194}
195
196func (*validateOpDescribeBackup) ID() string {
197	return "OperationInputValidation"
198}
199
200func (m *validateOpDescribeBackup) 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.(*DescribeBackupInput)
204	if !ok {
205		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
206	}
207	if err := validateOpDescribeBackupInput(input); err != nil {
208		return out, metadata, err
209	}
210	return next.HandleInitialize(ctx, in)
211}
212
213type validateOpDescribeContinuousBackups struct {
214}
215
216func (*validateOpDescribeContinuousBackups) ID() string {
217	return "OperationInputValidation"
218}
219
220func (m *validateOpDescribeContinuousBackups) 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.(*DescribeContinuousBackupsInput)
224	if !ok {
225		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
226	}
227	if err := validateOpDescribeContinuousBackupsInput(input); err != nil {
228		return out, metadata, err
229	}
230	return next.HandleInitialize(ctx, in)
231}
232
233type validateOpDescribeContributorInsights struct {
234}
235
236func (*validateOpDescribeContributorInsights) ID() string {
237	return "OperationInputValidation"
238}
239
240func (m *validateOpDescribeContributorInsights) 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.(*DescribeContributorInsightsInput)
244	if !ok {
245		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
246	}
247	if err := validateOpDescribeContributorInsightsInput(input); err != nil {
248		return out, metadata, err
249	}
250	return next.HandleInitialize(ctx, in)
251}
252
253type validateOpDescribeExport struct {
254}
255
256func (*validateOpDescribeExport) ID() string {
257	return "OperationInputValidation"
258}
259
260func (m *validateOpDescribeExport) 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.(*DescribeExportInput)
264	if !ok {
265		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
266	}
267	if err := validateOpDescribeExportInput(input); err != nil {
268		return out, metadata, err
269	}
270	return next.HandleInitialize(ctx, in)
271}
272
273type validateOpDescribeGlobalTable struct {
274}
275
276func (*validateOpDescribeGlobalTable) ID() string {
277	return "OperationInputValidation"
278}
279
280func (m *validateOpDescribeGlobalTable) 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.(*DescribeGlobalTableInput)
284	if !ok {
285		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
286	}
287	if err := validateOpDescribeGlobalTableInput(input); err != nil {
288		return out, metadata, err
289	}
290	return next.HandleInitialize(ctx, in)
291}
292
293type validateOpDescribeGlobalTableSettings struct {
294}
295
296func (*validateOpDescribeGlobalTableSettings) ID() string {
297	return "OperationInputValidation"
298}
299
300func (m *validateOpDescribeGlobalTableSettings) 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.(*DescribeGlobalTableSettingsInput)
304	if !ok {
305		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
306	}
307	if err := validateOpDescribeGlobalTableSettingsInput(input); err != nil {
308		return out, metadata, err
309	}
310	return next.HandleInitialize(ctx, in)
311}
312
313type validateOpDescribeKinesisStreamingDestination struct {
314}
315
316func (*validateOpDescribeKinesisStreamingDestination) ID() string {
317	return "OperationInputValidation"
318}
319
320func (m *validateOpDescribeKinesisStreamingDestination) 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.(*DescribeKinesisStreamingDestinationInput)
324	if !ok {
325		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
326	}
327	if err := validateOpDescribeKinesisStreamingDestinationInput(input); err != nil {
328		return out, metadata, err
329	}
330	return next.HandleInitialize(ctx, in)
331}
332
333type validateOpDescribeTable struct {
334}
335
336func (*validateOpDescribeTable) ID() string {
337	return "OperationInputValidation"
338}
339
340func (m *validateOpDescribeTable) 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.(*DescribeTableInput)
344	if !ok {
345		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
346	}
347	if err := validateOpDescribeTableInput(input); err != nil {
348		return out, metadata, err
349	}
350	return next.HandleInitialize(ctx, in)
351}
352
353type validateOpDescribeTableReplicaAutoScaling struct {
354}
355
356func (*validateOpDescribeTableReplicaAutoScaling) ID() string {
357	return "OperationInputValidation"
358}
359
360func (m *validateOpDescribeTableReplicaAutoScaling) 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.(*DescribeTableReplicaAutoScalingInput)
364	if !ok {
365		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
366	}
367	if err := validateOpDescribeTableReplicaAutoScalingInput(input); err != nil {
368		return out, metadata, err
369	}
370	return next.HandleInitialize(ctx, in)
371}
372
373type validateOpDescribeTimeToLive struct {
374}
375
376func (*validateOpDescribeTimeToLive) ID() string {
377	return "OperationInputValidation"
378}
379
380func (m *validateOpDescribeTimeToLive) 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.(*DescribeTimeToLiveInput)
384	if !ok {
385		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
386	}
387	if err := validateOpDescribeTimeToLiveInput(input); err != nil {
388		return out, metadata, err
389	}
390	return next.HandleInitialize(ctx, in)
391}
392
393type validateOpDisableKinesisStreamingDestination struct {
394}
395
396func (*validateOpDisableKinesisStreamingDestination) ID() string {
397	return "OperationInputValidation"
398}
399
400func (m *validateOpDisableKinesisStreamingDestination) 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.(*DisableKinesisStreamingDestinationInput)
404	if !ok {
405		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
406	}
407	if err := validateOpDisableKinesisStreamingDestinationInput(input); err != nil {
408		return out, metadata, err
409	}
410	return next.HandleInitialize(ctx, in)
411}
412
413type validateOpEnableKinesisStreamingDestination struct {
414}
415
416func (*validateOpEnableKinesisStreamingDestination) ID() string {
417	return "OperationInputValidation"
418}
419
420func (m *validateOpEnableKinesisStreamingDestination) 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.(*EnableKinesisStreamingDestinationInput)
424	if !ok {
425		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
426	}
427	if err := validateOpEnableKinesisStreamingDestinationInput(input); err != nil {
428		return out, metadata, err
429	}
430	return next.HandleInitialize(ctx, in)
431}
432
433type validateOpExecuteStatement struct {
434}
435
436func (*validateOpExecuteStatement) ID() string {
437	return "OperationInputValidation"
438}
439
440func (m *validateOpExecuteStatement) 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.(*ExecuteStatementInput)
444	if !ok {
445		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
446	}
447	if err := validateOpExecuteStatementInput(input); err != nil {
448		return out, metadata, err
449	}
450	return next.HandleInitialize(ctx, in)
451}
452
453type validateOpExecuteTransaction struct {
454}
455
456func (*validateOpExecuteTransaction) ID() string {
457	return "OperationInputValidation"
458}
459
460func (m *validateOpExecuteTransaction) 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.(*ExecuteTransactionInput)
464	if !ok {
465		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
466	}
467	if err := validateOpExecuteTransactionInput(input); err != nil {
468		return out, metadata, err
469	}
470	return next.HandleInitialize(ctx, in)
471}
472
473type validateOpExportTableToPointInTime struct {
474}
475
476func (*validateOpExportTableToPointInTime) ID() string {
477	return "OperationInputValidation"
478}
479
480func (m *validateOpExportTableToPointInTime) 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.(*ExportTableToPointInTimeInput)
484	if !ok {
485		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
486	}
487	if err := validateOpExportTableToPointInTimeInput(input); err != nil {
488		return out, metadata, err
489	}
490	return next.HandleInitialize(ctx, in)
491}
492
493type validateOpGetItem struct {
494}
495
496func (*validateOpGetItem) ID() string {
497	return "OperationInputValidation"
498}
499
500func (m *validateOpGetItem) 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.(*GetItemInput)
504	if !ok {
505		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
506	}
507	if err := validateOpGetItemInput(input); err != nil {
508		return out, metadata, err
509	}
510	return next.HandleInitialize(ctx, in)
511}
512
513type validateOpListTagsOfResource struct {
514}
515
516func (*validateOpListTagsOfResource) ID() string {
517	return "OperationInputValidation"
518}
519
520func (m *validateOpListTagsOfResource) 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.(*ListTagsOfResourceInput)
524	if !ok {
525		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
526	}
527	if err := validateOpListTagsOfResourceInput(input); err != nil {
528		return out, metadata, err
529	}
530	return next.HandleInitialize(ctx, in)
531}
532
533type validateOpPutItem struct {
534}
535
536func (*validateOpPutItem) ID() string {
537	return "OperationInputValidation"
538}
539
540func (m *validateOpPutItem) 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.(*PutItemInput)
544	if !ok {
545		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
546	}
547	if err := validateOpPutItemInput(input); err != nil {
548		return out, metadata, err
549	}
550	return next.HandleInitialize(ctx, in)
551}
552
553type validateOpQuery struct {
554}
555
556func (*validateOpQuery) ID() string {
557	return "OperationInputValidation"
558}
559
560func (m *validateOpQuery) 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.(*QueryInput)
564	if !ok {
565		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
566	}
567	if err := validateOpQueryInput(input); err != nil {
568		return out, metadata, err
569	}
570	return next.HandleInitialize(ctx, in)
571}
572
573type validateOpRestoreTableFromBackup struct {
574}
575
576func (*validateOpRestoreTableFromBackup) ID() string {
577	return "OperationInputValidation"
578}
579
580func (m *validateOpRestoreTableFromBackup) 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.(*RestoreTableFromBackupInput)
584	if !ok {
585		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
586	}
587	if err := validateOpRestoreTableFromBackupInput(input); err != nil {
588		return out, metadata, err
589	}
590	return next.HandleInitialize(ctx, in)
591}
592
593type validateOpRestoreTableToPointInTime struct {
594}
595
596func (*validateOpRestoreTableToPointInTime) ID() string {
597	return "OperationInputValidation"
598}
599
600func (m *validateOpRestoreTableToPointInTime) 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.(*RestoreTableToPointInTimeInput)
604	if !ok {
605		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
606	}
607	if err := validateOpRestoreTableToPointInTimeInput(input); err != nil {
608		return out, metadata, err
609	}
610	return next.HandleInitialize(ctx, in)
611}
612
613type validateOpScan struct {
614}
615
616func (*validateOpScan) ID() string {
617	return "OperationInputValidation"
618}
619
620func (m *validateOpScan) 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.(*ScanInput)
624	if !ok {
625		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
626	}
627	if err := validateOpScanInput(input); err != nil {
628		return out, metadata, err
629	}
630	return next.HandleInitialize(ctx, in)
631}
632
633type validateOpTagResource struct {
634}
635
636func (*validateOpTagResource) ID() string {
637	return "OperationInputValidation"
638}
639
640func (m *validateOpTagResource) 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.(*TagResourceInput)
644	if !ok {
645		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
646	}
647	if err := validateOpTagResourceInput(input); err != nil {
648		return out, metadata, err
649	}
650	return next.HandleInitialize(ctx, in)
651}
652
653type validateOpTransactGetItems struct {
654}
655
656func (*validateOpTransactGetItems) ID() string {
657	return "OperationInputValidation"
658}
659
660func (m *validateOpTransactGetItems) 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.(*TransactGetItemsInput)
664	if !ok {
665		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
666	}
667	if err := validateOpTransactGetItemsInput(input); err != nil {
668		return out, metadata, err
669	}
670	return next.HandleInitialize(ctx, in)
671}
672
673type validateOpTransactWriteItems struct {
674}
675
676func (*validateOpTransactWriteItems) ID() string {
677	return "OperationInputValidation"
678}
679
680func (m *validateOpTransactWriteItems) 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.(*TransactWriteItemsInput)
684	if !ok {
685		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
686	}
687	if err := validateOpTransactWriteItemsInput(input); err != nil {
688		return out, metadata, err
689	}
690	return next.HandleInitialize(ctx, in)
691}
692
693type validateOpUntagResource struct {
694}
695
696func (*validateOpUntagResource) ID() string {
697	return "OperationInputValidation"
698}
699
700func (m *validateOpUntagResource) 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.(*UntagResourceInput)
704	if !ok {
705		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
706	}
707	if err := validateOpUntagResourceInput(input); err != nil {
708		return out, metadata, err
709	}
710	return next.HandleInitialize(ctx, in)
711}
712
713type validateOpUpdateContinuousBackups struct {
714}
715
716func (*validateOpUpdateContinuousBackups) ID() string {
717	return "OperationInputValidation"
718}
719
720func (m *validateOpUpdateContinuousBackups) 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.(*UpdateContinuousBackupsInput)
724	if !ok {
725		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
726	}
727	if err := validateOpUpdateContinuousBackupsInput(input); err != nil {
728		return out, metadata, err
729	}
730	return next.HandleInitialize(ctx, in)
731}
732
733type validateOpUpdateContributorInsights struct {
734}
735
736func (*validateOpUpdateContributorInsights) ID() string {
737	return "OperationInputValidation"
738}
739
740func (m *validateOpUpdateContributorInsights) 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.(*UpdateContributorInsightsInput)
744	if !ok {
745		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
746	}
747	if err := validateOpUpdateContributorInsightsInput(input); err != nil {
748		return out, metadata, err
749	}
750	return next.HandleInitialize(ctx, in)
751}
752
753type validateOpUpdateGlobalTable struct {
754}
755
756func (*validateOpUpdateGlobalTable) ID() string {
757	return "OperationInputValidation"
758}
759
760func (m *validateOpUpdateGlobalTable) 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.(*UpdateGlobalTableInput)
764	if !ok {
765		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
766	}
767	if err := validateOpUpdateGlobalTableInput(input); err != nil {
768		return out, metadata, err
769	}
770	return next.HandleInitialize(ctx, in)
771}
772
773type validateOpUpdateGlobalTableSettings struct {
774}
775
776func (*validateOpUpdateGlobalTableSettings) ID() string {
777	return "OperationInputValidation"
778}
779
780func (m *validateOpUpdateGlobalTableSettings) 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.(*UpdateGlobalTableSettingsInput)
784	if !ok {
785		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
786	}
787	if err := validateOpUpdateGlobalTableSettingsInput(input); err != nil {
788		return out, metadata, err
789	}
790	return next.HandleInitialize(ctx, in)
791}
792
793type validateOpUpdateItem struct {
794}
795
796func (*validateOpUpdateItem) ID() string {
797	return "OperationInputValidation"
798}
799
800func (m *validateOpUpdateItem) 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.(*UpdateItemInput)
804	if !ok {
805		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
806	}
807	if err := validateOpUpdateItemInput(input); err != nil {
808		return out, metadata, err
809	}
810	return next.HandleInitialize(ctx, in)
811}
812
813type validateOpUpdateTable struct {
814}
815
816func (*validateOpUpdateTable) ID() string {
817	return "OperationInputValidation"
818}
819
820func (m *validateOpUpdateTable) 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.(*UpdateTableInput)
824	if !ok {
825		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
826	}
827	if err := validateOpUpdateTableInput(input); err != nil {
828		return out, metadata, err
829	}
830	return next.HandleInitialize(ctx, in)
831}
832
833type validateOpUpdateTableReplicaAutoScaling struct {
834}
835
836func (*validateOpUpdateTableReplicaAutoScaling) ID() string {
837	return "OperationInputValidation"
838}
839
840func (m *validateOpUpdateTableReplicaAutoScaling) 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.(*UpdateTableReplicaAutoScalingInput)
844	if !ok {
845		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
846	}
847	if err := validateOpUpdateTableReplicaAutoScalingInput(input); err != nil {
848		return out, metadata, err
849	}
850	return next.HandleInitialize(ctx, in)
851}
852
853type validateOpUpdateTimeToLive struct {
854}
855
856func (*validateOpUpdateTimeToLive) ID() string {
857	return "OperationInputValidation"
858}
859
860func (m *validateOpUpdateTimeToLive) 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.(*UpdateTimeToLiveInput)
864	if !ok {
865		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
866	}
867	if err := validateOpUpdateTimeToLiveInput(input); err != nil {
868		return out, metadata, err
869	}
870	return next.HandleInitialize(ctx, in)
871}
872
873func addOpBatchExecuteStatementValidationMiddleware(stack *middleware.Stack) error {
874	return stack.Initialize.Add(&validateOpBatchExecuteStatement{}, middleware.After)
875}
876
877func addOpBatchGetItemValidationMiddleware(stack *middleware.Stack) error {
878	return stack.Initialize.Add(&validateOpBatchGetItem{}, middleware.After)
879}
880
881func addOpBatchWriteItemValidationMiddleware(stack *middleware.Stack) error {
882	return stack.Initialize.Add(&validateOpBatchWriteItem{}, middleware.After)
883}
884
885func addOpCreateBackupValidationMiddleware(stack *middleware.Stack) error {
886	return stack.Initialize.Add(&validateOpCreateBackup{}, middleware.After)
887}
888
889func addOpCreateGlobalTableValidationMiddleware(stack *middleware.Stack) error {
890	return stack.Initialize.Add(&validateOpCreateGlobalTable{}, middleware.After)
891}
892
893func addOpCreateTableValidationMiddleware(stack *middleware.Stack) error {
894	return stack.Initialize.Add(&validateOpCreateTable{}, middleware.After)
895}
896
897func addOpDeleteBackupValidationMiddleware(stack *middleware.Stack) error {
898	return stack.Initialize.Add(&validateOpDeleteBackup{}, middleware.After)
899}
900
901func addOpDeleteItemValidationMiddleware(stack *middleware.Stack) error {
902	return stack.Initialize.Add(&validateOpDeleteItem{}, middleware.After)
903}
904
905func addOpDeleteTableValidationMiddleware(stack *middleware.Stack) error {
906	return stack.Initialize.Add(&validateOpDeleteTable{}, middleware.After)
907}
908
909func addOpDescribeBackupValidationMiddleware(stack *middleware.Stack) error {
910	return stack.Initialize.Add(&validateOpDescribeBackup{}, middleware.After)
911}
912
913func addOpDescribeContinuousBackupsValidationMiddleware(stack *middleware.Stack) error {
914	return stack.Initialize.Add(&validateOpDescribeContinuousBackups{}, middleware.After)
915}
916
917func addOpDescribeContributorInsightsValidationMiddleware(stack *middleware.Stack) error {
918	return stack.Initialize.Add(&validateOpDescribeContributorInsights{}, middleware.After)
919}
920
921func addOpDescribeExportValidationMiddleware(stack *middleware.Stack) error {
922	return stack.Initialize.Add(&validateOpDescribeExport{}, middleware.After)
923}
924
925func addOpDescribeGlobalTableValidationMiddleware(stack *middleware.Stack) error {
926	return stack.Initialize.Add(&validateOpDescribeGlobalTable{}, middleware.After)
927}
928
929func addOpDescribeGlobalTableSettingsValidationMiddleware(stack *middleware.Stack) error {
930	return stack.Initialize.Add(&validateOpDescribeGlobalTableSettings{}, middleware.After)
931}
932
933func addOpDescribeKinesisStreamingDestinationValidationMiddleware(stack *middleware.Stack) error {
934	return stack.Initialize.Add(&validateOpDescribeKinesisStreamingDestination{}, middleware.After)
935}
936
937func addOpDescribeTableValidationMiddleware(stack *middleware.Stack) error {
938	return stack.Initialize.Add(&validateOpDescribeTable{}, middleware.After)
939}
940
941func addOpDescribeTableReplicaAutoScalingValidationMiddleware(stack *middleware.Stack) error {
942	return stack.Initialize.Add(&validateOpDescribeTableReplicaAutoScaling{}, middleware.After)
943}
944
945func addOpDescribeTimeToLiveValidationMiddleware(stack *middleware.Stack) error {
946	return stack.Initialize.Add(&validateOpDescribeTimeToLive{}, middleware.After)
947}
948
949func addOpDisableKinesisStreamingDestinationValidationMiddleware(stack *middleware.Stack) error {
950	return stack.Initialize.Add(&validateOpDisableKinesisStreamingDestination{}, middleware.After)
951}
952
953func addOpEnableKinesisStreamingDestinationValidationMiddleware(stack *middleware.Stack) error {
954	return stack.Initialize.Add(&validateOpEnableKinesisStreamingDestination{}, middleware.After)
955}
956
957func addOpExecuteStatementValidationMiddleware(stack *middleware.Stack) error {
958	return stack.Initialize.Add(&validateOpExecuteStatement{}, middleware.After)
959}
960
961func addOpExecuteTransactionValidationMiddleware(stack *middleware.Stack) error {
962	return stack.Initialize.Add(&validateOpExecuteTransaction{}, middleware.After)
963}
964
965func addOpExportTableToPointInTimeValidationMiddleware(stack *middleware.Stack) error {
966	return stack.Initialize.Add(&validateOpExportTableToPointInTime{}, middleware.After)
967}
968
969func addOpGetItemValidationMiddleware(stack *middleware.Stack) error {
970	return stack.Initialize.Add(&validateOpGetItem{}, middleware.After)
971}
972
973func addOpListTagsOfResourceValidationMiddleware(stack *middleware.Stack) error {
974	return stack.Initialize.Add(&validateOpListTagsOfResource{}, middleware.After)
975}
976
977func addOpPutItemValidationMiddleware(stack *middleware.Stack) error {
978	return stack.Initialize.Add(&validateOpPutItem{}, middleware.After)
979}
980
981func addOpQueryValidationMiddleware(stack *middleware.Stack) error {
982	return stack.Initialize.Add(&validateOpQuery{}, middleware.After)
983}
984
985func addOpRestoreTableFromBackupValidationMiddleware(stack *middleware.Stack) error {
986	return stack.Initialize.Add(&validateOpRestoreTableFromBackup{}, middleware.After)
987}
988
989func addOpRestoreTableToPointInTimeValidationMiddleware(stack *middleware.Stack) error {
990	return stack.Initialize.Add(&validateOpRestoreTableToPointInTime{}, middleware.After)
991}
992
993func addOpScanValidationMiddleware(stack *middleware.Stack) error {
994	return stack.Initialize.Add(&validateOpScan{}, middleware.After)
995}
996
997func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
998	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
999}
1000
1001func addOpTransactGetItemsValidationMiddleware(stack *middleware.Stack) error {
1002	return stack.Initialize.Add(&validateOpTransactGetItems{}, middleware.After)
1003}
1004
1005func addOpTransactWriteItemsValidationMiddleware(stack *middleware.Stack) error {
1006	return stack.Initialize.Add(&validateOpTransactWriteItems{}, middleware.After)
1007}
1008
1009func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
1010	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
1011}
1012
1013func addOpUpdateContinuousBackupsValidationMiddleware(stack *middleware.Stack) error {
1014	return stack.Initialize.Add(&validateOpUpdateContinuousBackups{}, middleware.After)
1015}
1016
1017func addOpUpdateContributorInsightsValidationMiddleware(stack *middleware.Stack) error {
1018	return stack.Initialize.Add(&validateOpUpdateContributorInsights{}, middleware.After)
1019}
1020
1021func addOpUpdateGlobalTableValidationMiddleware(stack *middleware.Stack) error {
1022	return stack.Initialize.Add(&validateOpUpdateGlobalTable{}, middleware.After)
1023}
1024
1025func addOpUpdateGlobalTableSettingsValidationMiddleware(stack *middleware.Stack) error {
1026	return stack.Initialize.Add(&validateOpUpdateGlobalTableSettings{}, middleware.After)
1027}
1028
1029func addOpUpdateItemValidationMiddleware(stack *middleware.Stack) error {
1030	return stack.Initialize.Add(&validateOpUpdateItem{}, middleware.After)
1031}
1032
1033func addOpUpdateTableValidationMiddleware(stack *middleware.Stack) error {
1034	return stack.Initialize.Add(&validateOpUpdateTable{}, middleware.After)
1035}
1036
1037func addOpUpdateTableReplicaAutoScalingValidationMiddleware(stack *middleware.Stack) error {
1038	return stack.Initialize.Add(&validateOpUpdateTableReplicaAutoScaling{}, middleware.After)
1039}
1040
1041func addOpUpdateTimeToLiveValidationMiddleware(stack *middleware.Stack) error {
1042	return stack.Initialize.Add(&validateOpUpdateTimeToLive{}, middleware.After)
1043}
1044
1045func validateAttributeDefinition(v *types.AttributeDefinition) error {
1046	if v == nil {
1047		return nil
1048	}
1049	invalidParams := smithy.InvalidParamsError{Context: "AttributeDefinition"}
1050	if v.AttributeName == nil {
1051		invalidParams.Add(smithy.NewErrParamRequired("AttributeName"))
1052	}
1053	if len(v.AttributeType) == 0 {
1054		invalidParams.Add(smithy.NewErrParamRequired("AttributeType"))
1055	}
1056	if invalidParams.Len() > 0 {
1057		return invalidParams
1058	} else {
1059		return nil
1060	}
1061}
1062
1063func validateAttributeDefinitions(v []types.AttributeDefinition) error {
1064	if v == nil {
1065		return nil
1066	}
1067	invalidParams := smithy.InvalidParamsError{Context: "AttributeDefinitions"}
1068	for i := range v {
1069		if err := validateAttributeDefinition(&v[i]); err != nil {
1070			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1071		}
1072	}
1073	if invalidParams.Len() > 0 {
1074		return invalidParams
1075	} else {
1076		return nil
1077	}
1078}
1079
1080func validateAutoScalingPolicyUpdate(v *types.AutoScalingPolicyUpdate) error {
1081	if v == nil {
1082		return nil
1083	}
1084	invalidParams := smithy.InvalidParamsError{Context: "AutoScalingPolicyUpdate"}
1085	if v.TargetTrackingScalingPolicyConfiguration == nil {
1086		invalidParams.Add(smithy.NewErrParamRequired("TargetTrackingScalingPolicyConfiguration"))
1087	} else if v.TargetTrackingScalingPolicyConfiguration != nil {
1088		if err := validateAutoScalingTargetTrackingScalingPolicyConfigurationUpdate(v.TargetTrackingScalingPolicyConfiguration); err != nil {
1089			invalidParams.AddNested("TargetTrackingScalingPolicyConfiguration", err.(smithy.InvalidParamsError))
1090		}
1091	}
1092	if invalidParams.Len() > 0 {
1093		return invalidParams
1094	} else {
1095		return nil
1096	}
1097}
1098
1099func validateAutoScalingSettingsUpdate(v *types.AutoScalingSettingsUpdate) error {
1100	if v == nil {
1101		return nil
1102	}
1103	invalidParams := smithy.InvalidParamsError{Context: "AutoScalingSettingsUpdate"}
1104	if v.ScalingPolicyUpdate != nil {
1105		if err := validateAutoScalingPolicyUpdate(v.ScalingPolicyUpdate); err != nil {
1106			invalidParams.AddNested("ScalingPolicyUpdate", err.(smithy.InvalidParamsError))
1107		}
1108	}
1109	if invalidParams.Len() > 0 {
1110		return invalidParams
1111	} else {
1112		return nil
1113	}
1114}
1115
1116func validateAutoScalingTargetTrackingScalingPolicyConfigurationUpdate(v *types.AutoScalingTargetTrackingScalingPolicyConfigurationUpdate) error {
1117	if v == nil {
1118		return nil
1119	}
1120	invalidParams := smithy.InvalidParamsError{Context: "AutoScalingTargetTrackingScalingPolicyConfigurationUpdate"}
1121	if v.TargetValue == nil {
1122		invalidParams.Add(smithy.NewErrParamRequired("TargetValue"))
1123	}
1124	if invalidParams.Len() > 0 {
1125		return invalidParams
1126	} else {
1127		return nil
1128	}
1129}
1130
1131func validateBatchGetRequestMap(v map[string]types.KeysAndAttributes) error {
1132	if v == nil {
1133		return nil
1134	}
1135	invalidParams := smithy.InvalidParamsError{Context: "BatchGetRequestMap"}
1136	for key := range v {
1137		value := v[key]
1138		if err := validateKeysAndAttributes(&value); err != nil {
1139			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
1140		}
1141	}
1142	if invalidParams.Len() > 0 {
1143		return invalidParams
1144	} else {
1145		return nil
1146	}
1147}
1148
1149func validateBatchStatementRequest(v *types.BatchStatementRequest) error {
1150	if v == nil {
1151		return nil
1152	}
1153	invalidParams := smithy.InvalidParamsError{Context: "BatchStatementRequest"}
1154	if v.Statement == nil {
1155		invalidParams.Add(smithy.NewErrParamRequired("Statement"))
1156	}
1157	if invalidParams.Len() > 0 {
1158		return invalidParams
1159	} else {
1160		return nil
1161	}
1162}
1163
1164func validateBatchWriteItemRequestMap(v map[string][]types.WriteRequest) error {
1165	if v == nil {
1166		return nil
1167	}
1168	invalidParams := smithy.InvalidParamsError{Context: "BatchWriteItemRequestMap"}
1169	for key := range v {
1170		if err := validateWriteRequests(v[key]); err != nil {
1171			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
1172		}
1173	}
1174	if invalidParams.Len() > 0 {
1175		return invalidParams
1176	} else {
1177		return nil
1178	}
1179}
1180
1181func validateCondition(v *types.Condition) error {
1182	if v == nil {
1183		return nil
1184	}
1185	invalidParams := smithy.InvalidParamsError{Context: "Condition"}
1186	if len(v.ComparisonOperator) == 0 {
1187		invalidParams.Add(smithy.NewErrParamRequired("ComparisonOperator"))
1188	}
1189	if invalidParams.Len() > 0 {
1190		return invalidParams
1191	} else {
1192		return nil
1193	}
1194}
1195
1196func validateConditionCheck(v *types.ConditionCheck) error {
1197	if v == nil {
1198		return nil
1199	}
1200	invalidParams := smithy.InvalidParamsError{Context: "ConditionCheck"}
1201	if v.Key == nil {
1202		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1203	}
1204	if v.TableName == nil {
1205		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
1206	}
1207	if v.ConditionExpression == nil {
1208		invalidParams.Add(smithy.NewErrParamRequired("ConditionExpression"))
1209	}
1210	if invalidParams.Len() > 0 {
1211		return invalidParams
1212	} else {
1213		return nil
1214	}
1215}
1216
1217func validateCreateGlobalSecondaryIndexAction(v *types.CreateGlobalSecondaryIndexAction) error {
1218	if v == nil {
1219		return nil
1220	}
1221	invalidParams := smithy.InvalidParamsError{Context: "CreateGlobalSecondaryIndexAction"}
1222	if v.IndexName == nil {
1223		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
1224	}
1225	if v.KeySchema == nil {
1226		invalidParams.Add(smithy.NewErrParamRequired("KeySchema"))
1227	} else if v.KeySchema != nil {
1228		if err := validateKeySchema(v.KeySchema); err != nil {
1229			invalidParams.AddNested("KeySchema", err.(smithy.InvalidParamsError))
1230		}
1231	}
1232	if v.Projection == nil {
1233		invalidParams.Add(smithy.NewErrParamRequired("Projection"))
1234	}
1235	if v.ProvisionedThroughput != nil {
1236		if err := validateProvisionedThroughput(v.ProvisionedThroughput); err != nil {
1237			invalidParams.AddNested("ProvisionedThroughput", err.(smithy.InvalidParamsError))
1238		}
1239	}
1240	if invalidParams.Len() > 0 {
1241		return invalidParams
1242	} else {
1243		return nil
1244	}
1245}
1246
1247func validateCreateReplicaAction(v *types.CreateReplicaAction) error {
1248	if v == nil {
1249		return nil
1250	}
1251	invalidParams := smithy.InvalidParamsError{Context: "CreateReplicaAction"}
1252	if v.RegionName == nil {
1253		invalidParams.Add(smithy.NewErrParamRequired("RegionName"))
1254	}
1255	if invalidParams.Len() > 0 {
1256		return invalidParams
1257	} else {
1258		return nil
1259	}
1260}
1261
1262func validateCreateReplicationGroupMemberAction(v *types.CreateReplicationGroupMemberAction) error {
1263	if v == nil {
1264		return nil
1265	}
1266	invalidParams := smithy.InvalidParamsError{Context: "CreateReplicationGroupMemberAction"}
1267	if v.RegionName == nil {
1268		invalidParams.Add(smithy.NewErrParamRequired("RegionName"))
1269	}
1270	if v.GlobalSecondaryIndexes != nil {
1271		if err := validateReplicaGlobalSecondaryIndexList(v.GlobalSecondaryIndexes); err != nil {
1272			invalidParams.AddNested("GlobalSecondaryIndexes", err.(smithy.InvalidParamsError))
1273		}
1274	}
1275	if invalidParams.Len() > 0 {
1276		return invalidParams
1277	} else {
1278		return nil
1279	}
1280}
1281
1282func validateDelete(v *types.Delete) error {
1283	if v == nil {
1284		return nil
1285	}
1286	invalidParams := smithy.InvalidParamsError{Context: "Delete"}
1287	if v.Key == nil {
1288		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1289	}
1290	if v.TableName == nil {
1291		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
1292	}
1293	if invalidParams.Len() > 0 {
1294		return invalidParams
1295	} else {
1296		return nil
1297	}
1298}
1299
1300func validateDeleteGlobalSecondaryIndexAction(v *types.DeleteGlobalSecondaryIndexAction) error {
1301	if v == nil {
1302		return nil
1303	}
1304	invalidParams := smithy.InvalidParamsError{Context: "DeleteGlobalSecondaryIndexAction"}
1305	if v.IndexName == nil {
1306		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
1307	}
1308	if invalidParams.Len() > 0 {
1309		return invalidParams
1310	} else {
1311		return nil
1312	}
1313}
1314
1315func validateDeleteReplicaAction(v *types.DeleteReplicaAction) error {
1316	if v == nil {
1317		return nil
1318	}
1319	invalidParams := smithy.InvalidParamsError{Context: "DeleteReplicaAction"}
1320	if v.RegionName == nil {
1321		invalidParams.Add(smithy.NewErrParamRequired("RegionName"))
1322	}
1323	if invalidParams.Len() > 0 {
1324		return invalidParams
1325	} else {
1326		return nil
1327	}
1328}
1329
1330func validateDeleteReplicationGroupMemberAction(v *types.DeleteReplicationGroupMemberAction) error {
1331	if v == nil {
1332		return nil
1333	}
1334	invalidParams := smithy.InvalidParamsError{Context: "DeleteReplicationGroupMemberAction"}
1335	if v.RegionName == nil {
1336		invalidParams.Add(smithy.NewErrParamRequired("RegionName"))
1337	}
1338	if invalidParams.Len() > 0 {
1339		return invalidParams
1340	} else {
1341		return nil
1342	}
1343}
1344
1345func validateDeleteRequest(v *types.DeleteRequest) error {
1346	if v == nil {
1347		return nil
1348	}
1349	invalidParams := smithy.InvalidParamsError{Context: "DeleteRequest"}
1350	if v.Key == nil {
1351		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1352	}
1353	if invalidParams.Len() > 0 {
1354		return invalidParams
1355	} else {
1356		return nil
1357	}
1358}
1359
1360func validateFilterConditionMap(v map[string]types.Condition) error {
1361	if v == nil {
1362		return nil
1363	}
1364	invalidParams := smithy.InvalidParamsError{Context: "FilterConditionMap"}
1365	for key := range v {
1366		value := v[key]
1367		if err := validateCondition(&value); err != nil {
1368			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
1369		}
1370	}
1371	if invalidParams.Len() > 0 {
1372		return invalidParams
1373	} else {
1374		return nil
1375	}
1376}
1377
1378func validateGet(v *types.Get) error {
1379	if v == nil {
1380		return nil
1381	}
1382	invalidParams := smithy.InvalidParamsError{Context: "Get"}
1383	if v.Key == nil {
1384		invalidParams.Add(smithy.NewErrParamRequired("Key"))
1385	}
1386	if v.TableName == nil {
1387		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
1388	}
1389	if invalidParams.Len() > 0 {
1390		return invalidParams
1391	} else {
1392		return nil
1393	}
1394}
1395
1396func validateGlobalSecondaryIndex(v *types.GlobalSecondaryIndex) error {
1397	if v == nil {
1398		return nil
1399	}
1400	invalidParams := smithy.InvalidParamsError{Context: "GlobalSecondaryIndex"}
1401	if v.IndexName == nil {
1402		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
1403	}
1404	if v.KeySchema == nil {
1405		invalidParams.Add(smithy.NewErrParamRequired("KeySchema"))
1406	} else if v.KeySchema != nil {
1407		if err := validateKeySchema(v.KeySchema); err != nil {
1408			invalidParams.AddNested("KeySchema", err.(smithy.InvalidParamsError))
1409		}
1410	}
1411	if v.Projection == nil {
1412		invalidParams.Add(smithy.NewErrParamRequired("Projection"))
1413	}
1414	if v.ProvisionedThroughput != nil {
1415		if err := validateProvisionedThroughput(v.ProvisionedThroughput); err != nil {
1416			invalidParams.AddNested("ProvisionedThroughput", err.(smithy.InvalidParamsError))
1417		}
1418	}
1419	if invalidParams.Len() > 0 {
1420		return invalidParams
1421	} else {
1422		return nil
1423	}
1424}
1425
1426func validateGlobalSecondaryIndexAutoScalingUpdate(v *types.GlobalSecondaryIndexAutoScalingUpdate) error {
1427	if v == nil {
1428		return nil
1429	}
1430	invalidParams := smithy.InvalidParamsError{Context: "GlobalSecondaryIndexAutoScalingUpdate"}
1431	if v.ProvisionedWriteCapacityAutoScalingUpdate != nil {
1432		if err := validateAutoScalingSettingsUpdate(v.ProvisionedWriteCapacityAutoScalingUpdate); err != nil {
1433			invalidParams.AddNested("ProvisionedWriteCapacityAutoScalingUpdate", err.(smithy.InvalidParamsError))
1434		}
1435	}
1436	if invalidParams.Len() > 0 {
1437		return invalidParams
1438	} else {
1439		return nil
1440	}
1441}
1442
1443func validateGlobalSecondaryIndexAutoScalingUpdateList(v []types.GlobalSecondaryIndexAutoScalingUpdate) error {
1444	if v == nil {
1445		return nil
1446	}
1447	invalidParams := smithy.InvalidParamsError{Context: "GlobalSecondaryIndexAutoScalingUpdateList"}
1448	for i := range v {
1449		if err := validateGlobalSecondaryIndexAutoScalingUpdate(&v[i]); err != nil {
1450			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1451		}
1452	}
1453	if invalidParams.Len() > 0 {
1454		return invalidParams
1455	} else {
1456		return nil
1457	}
1458}
1459
1460func validateGlobalSecondaryIndexList(v []types.GlobalSecondaryIndex) error {
1461	if v == nil {
1462		return nil
1463	}
1464	invalidParams := smithy.InvalidParamsError{Context: "GlobalSecondaryIndexList"}
1465	for i := range v {
1466		if err := validateGlobalSecondaryIndex(&v[i]); err != nil {
1467			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1468		}
1469	}
1470	if invalidParams.Len() > 0 {
1471		return invalidParams
1472	} else {
1473		return nil
1474	}
1475}
1476
1477func validateGlobalSecondaryIndexUpdate(v *types.GlobalSecondaryIndexUpdate) error {
1478	if v == nil {
1479		return nil
1480	}
1481	invalidParams := smithy.InvalidParamsError{Context: "GlobalSecondaryIndexUpdate"}
1482	if v.Update != nil {
1483		if err := validateUpdateGlobalSecondaryIndexAction(v.Update); err != nil {
1484			invalidParams.AddNested("Update", err.(smithy.InvalidParamsError))
1485		}
1486	}
1487	if v.Create != nil {
1488		if err := validateCreateGlobalSecondaryIndexAction(v.Create); err != nil {
1489			invalidParams.AddNested("Create", err.(smithy.InvalidParamsError))
1490		}
1491	}
1492	if v.Delete != nil {
1493		if err := validateDeleteGlobalSecondaryIndexAction(v.Delete); err != nil {
1494			invalidParams.AddNested("Delete", err.(smithy.InvalidParamsError))
1495		}
1496	}
1497	if invalidParams.Len() > 0 {
1498		return invalidParams
1499	} else {
1500		return nil
1501	}
1502}
1503
1504func validateGlobalSecondaryIndexUpdateList(v []types.GlobalSecondaryIndexUpdate) error {
1505	if v == nil {
1506		return nil
1507	}
1508	invalidParams := smithy.InvalidParamsError{Context: "GlobalSecondaryIndexUpdateList"}
1509	for i := range v {
1510		if err := validateGlobalSecondaryIndexUpdate(&v[i]); err != nil {
1511			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1512		}
1513	}
1514	if invalidParams.Len() > 0 {
1515		return invalidParams
1516	} else {
1517		return nil
1518	}
1519}
1520
1521func validateGlobalTableGlobalSecondaryIndexSettingsUpdate(v *types.GlobalTableGlobalSecondaryIndexSettingsUpdate) error {
1522	if v == nil {
1523		return nil
1524	}
1525	invalidParams := smithy.InvalidParamsError{Context: "GlobalTableGlobalSecondaryIndexSettingsUpdate"}
1526	if v.IndexName == nil {
1527		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
1528	}
1529	if v.ProvisionedWriteCapacityAutoScalingSettingsUpdate != nil {
1530		if err := validateAutoScalingSettingsUpdate(v.ProvisionedWriteCapacityAutoScalingSettingsUpdate); err != nil {
1531			invalidParams.AddNested("ProvisionedWriteCapacityAutoScalingSettingsUpdate", err.(smithy.InvalidParamsError))
1532		}
1533	}
1534	if invalidParams.Len() > 0 {
1535		return invalidParams
1536	} else {
1537		return nil
1538	}
1539}
1540
1541func validateGlobalTableGlobalSecondaryIndexSettingsUpdateList(v []types.GlobalTableGlobalSecondaryIndexSettingsUpdate) error {
1542	if v == nil {
1543		return nil
1544	}
1545	invalidParams := smithy.InvalidParamsError{Context: "GlobalTableGlobalSecondaryIndexSettingsUpdateList"}
1546	for i := range v {
1547		if err := validateGlobalTableGlobalSecondaryIndexSettingsUpdate(&v[i]); err != nil {
1548			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1549		}
1550	}
1551	if invalidParams.Len() > 0 {
1552		return invalidParams
1553	} else {
1554		return nil
1555	}
1556}
1557
1558func validateKeyConditions(v map[string]types.Condition) error {
1559	if v == nil {
1560		return nil
1561	}
1562	invalidParams := smithy.InvalidParamsError{Context: "KeyConditions"}
1563	for key := range v {
1564		value := v[key]
1565		if err := validateCondition(&value); err != nil {
1566			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
1567		}
1568	}
1569	if invalidParams.Len() > 0 {
1570		return invalidParams
1571	} else {
1572		return nil
1573	}
1574}
1575
1576func validateKeysAndAttributes(v *types.KeysAndAttributes) error {
1577	if v == nil {
1578		return nil
1579	}
1580	invalidParams := smithy.InvalidParamsError{Context: "KeysAndAttributes"}
1581	if v.Keys == nil {
1582		invalidParams.Add(smithy.NewErrParamRequired("Keys"))
1583	}
1584	if invalidParams.Len() > 0 {
1585		return invalidParams
1586	} else {
1587		return nil
1588	}
1589}
1590
1591func validateKeySchema(v []types.KeySchemaElement) error {
1592	if v == nil {
1593		return nil
1594	}
1595	invalidParams := smithy.InvalidParamsError{Context: "KeySchema"}
1596	for i := range v {
1597		if err := validateKeySchemaElement(&v[i]); err != nil {
1598			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1599		}
1600	}
1601	if invalidParams.Len() > 0 {
1602		return invalidParams
1603	} else {
1604		return nil
1605	}
1606}
1607
1608func validateKeySchemaElement(v *types.KeySchemaElement) error {
1609	if v == nil {
1610		return nil
1611	}
1612	invalidParams := smithy.InvalidParamsError{Context: "KeySchemaElement"}
1613	if v.AttributeName == nil {
1614		invalidParams.Add(smithy.NewErrParamRequired("AttributeName"))
1615	}
1616	if len(v.KeyType) == 0 {
1617		invalidParams.Add(smithy.NewErrParamRequired("KeyType"))
1618	}
1619	if invalidParams.Len() > 0 {
1620		return invalidParams
1621	} else {
1622		return nil
1623	}
1624}
1625
1626func validateLocalSecondaryIndex(v *types.LocalSecondaryIndex) error {
1627	if v == nil {
1628		return nil
1629	}
1630	invalidParams := smithy.InvalidParamsError{Context: "LocalSecondaryIndex"}
1631	if v.IndexName == nil {
1632		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
1633	}
1634	if v.KeySchema == nil {
1635		invalidParams.Add(smithy.NewErrParamRequired("KeySchema"))
1636	} else if v.KeySchema != nil {
1637		if err := validateKeySchema(v.KeySchema); err != nil {
1638			invalidParams.AddNested("KeySchema", err.(smithy.InvalidParamsError))
1639		}
1640	}
1641	if v.Projection == nil {
1642		invalidParams.Add(smithy.NewErrParamRequired("Projection"))
1643	}
1644	if invalidParams.Len() > 0 {
1645		return invalidParams
1646	} else {
1647		return nil
1648	}
1649}
1650
1651func validateLocalSecondaryIndexList(v []types.LocalSecondaryIndex) error {
1652	if v == nil {
1653		return nil
1654	}
1655	invalidParams := smithy.InvalidParamsError{Context: "LocalSecondaryIndexList"}
1656	for i := range v {
1657		if err := validateLocalSecondaryIndex(&v[i]); err != nil {
1658			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1659		}
1660	}
1661	if invalidParams.Len() > 0 {
1662		return invalidParams
1663	} else {
1664		return nil
1665	}
1666}
1667
1668func validateParameterizedStatement(v *types.ParameterizedStatement) error {
1669	if v == nil {
1670		return nil
1671	}
1672	invalidParams := smithy.InvalidParamsError{Context: "ParameterizedStatement"}
1673	if v.Statement == nil {
1674		invalidParams.Add(smithy.NewErrParamRequired("Statement"))
1675	}
1676	if invalidParams.Len() > 0 {
1677		return invalidParams
1678	} else {
1679		return nil
1680	}
1681}
1682
1683func validateParameterizedStatements(v []types.ParameterizedStatement) error {
1684	if v == nil {
1685		return nil
1686	}
1687	invalidParams := smithy.InvalidParamsError{Context: "ParameterizedStatements"}
1688	for i := range v {
1689		if err := validateParameterizedStatement(&v[i]); err != nil {
1690			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1691		}
1692	}
1693	if invalidParams.Len() > 0 {
1694		return invalidParams
1695	} else {
1696		return nil
1697	}
1698}
1699
1700func validatePartiQLBatchRequest(v []types.BatchStatementRequest) error {
1701	if v == nil {
1702		return nil
1703	}
1704	invalidParams := smithy.InvalidParamsError{Context: "PartiQLBatchRequest"}
1705	for i := range v {
1706		if err := validateBatchStatementRequest(&v[i]); err != nil {
1707			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1708		}
1709	}
1710	if invalidParams.Len() > 0 {
1711		return invalidParams
1712	} else {
1713		return nil
1714	}
1715}
1716
1717func validatePointInTimeRecoverySpecification(v *types.PointInTimeRecoverySpecification) error {
1718	if v == nil {
1719		return nil
1720	}
1721	invalidParams := smithy.InvalidParamsError{Context: "PointInTimeRecoverySpecification"}
1722	if v.PointInTimeRecoveryEnabled == nil {
1723		invalidParams.Add(smithy.NewErrParamRequired("PointInTimeRecoveryEnabled"))
1724	}
1725	if invalidParams.Len() > 0 {
1726		return invalidParams
1727	} else {
1728		return nil
1729	}
1730}
1731
1732func validateProvisionedThroughput(v *types.ProvisionedThroughput) error {
1733	if v == nil {
1734		return nil
1735	}
1736	invalidParams := smithy.InvalidParamsError{Context: "ProvisionedThroughput"}
1737	if v.ReadCapacityUnits == nil {
1738		invalidParams.Add(smithy.NewErrParamRequired("ReadCapacityUnits"))
1739	}
1740	if v.WriteCapacityUnits == nil {
1741		invalidParams.Add(smithy.NewErrParamRequired("WriteCapacityUnits"))
1742	}
1743	if invalidParams.Len() > 0 {
1744		return invalidParams
1745	} else {
1746		return nil
1747	}
1748}
1749
1750func validatePut(v *types.Put) error {
1751	if v == nil {
1752		return nil
1753	}
1754	invalidParams := smithy.InvalidParamsError{Context: "Put"}
1755	if v.Item == nil {
1756		invalidParams.Add(smithy.NewErrParamRequired("Item"))
1757	}
1758	if v.TableName == nil {
1759		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
1760	}
1761	if invalidParams.Len() > 0 {
1762		return invalidParams
1763	} else {
1764		return nil
1765	}
1766}
1767
1768func validatePutRequest(v *types.PutRequest) error {
1769	if v == nil {
1770		return nil
1771	}
1772	invalidParams := smithy.InvalidParamsError{Context: "PutRequest"}
1773	if v.Item == nil {
1774		invalidParams.Add(smithy.NewErrParamRequired("Item"))
1775	}
1776	if invalidParams.Len() > 0 {
1777		return invalidParams
1778	} else {
1779		return nil
1780	}
1781}
1782
1783func validateReplicaAutoScalingUpdate(v *types.ReplicaAutoScalingUpdate) error {
1784	if v == nil {
1785		return nil
1786	}
1787	invalidParams := smithy.InvalidParamsError{Context: "ReplicaAutoScalingUpdate"}
1788	if v.RegionName == nil {
1789		invalidParams.Add(smithy.NewErrParamRequired("RegionName"))
1790	}
1791	if v.ReplicaGlobalSecondaryIndexUpdates != nil {
1792		if err := validateReplicaGlobalSecondaryIndexAutoScalingUpdateList(v.ReplicaGlobalSecondaryIndexUpdates); err != nil {
1793			invalidParams.AddNested("ReplicaGlobalSecondaryIndexUpdates", err.(smithy.InvalidParamsError))
1794		}
1795	}
1796	if v.ReplicaProvisionedReadCapacityAutoScalingUpdate != nil {
1797		if err := validateAutoScalingSettingsUpdate(v.ReplicaProvisionedReadCapacityAutoScalingUpdate); err != nil {
1798			invalidParams.AddNested("ReplicaProvisionedReadCapacityAutoScalingUpdate", err.(smithy.InvalidParamsError))
1799		}
1800	}
1801	if invalidParams.Len() > 0 {
1802		return invalidParams
1803	} else {
1804		return nil
1805	}
1806}
1807
1808func validateReplicaAutoScalingUpdateList(v []types.ReplicaAutoScalingUpdate) error {
1809	if v == nil {
1810		return nil
1811	}
1812	invalidParams := smithy.InvalidParamsError{Context: "ReplicaAutoScalingUpdateList"}
1813	for i := range v {
1814		if err := validateReplicaAutoScalingUpdate(&v[i]); err != nil {
1815			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1816		}
1817	}
1818	if invalidParams.Len() > 0 {
1819		return invalidParams
1820	} else {
1821		return nil
1822	}
1823}
1824
1825func validateReplicaGlobalSecondaryIndex(v *types.ReplicaGlobalSecondaryIndex) error {
1826	if v == nil {
1827		return nil
1828	}
1829	invalidParams := smithy.InvalidParamsError{Context: "ReplicaGlobalSecondaryIndex"}
1830	if v.IndexName == nil {
1831		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
1832	}
1833	if invalidParams.Len() > 0 {
1834		return invalidParams
1835	} else {
1836		return nil
1837	}
1838}
1839
1840func validateReplicaGlobalSecondaryIndexAutoScalingUpdate(v *types.ReplicaGlobalSecondaryIndexAutoScalingUpdate) error {
1841	if v == nil {
1842		return nil
1843	}
1844	invalidParams := smithy.InvalidParamsError{Context: "ReplicaGlobalSecondaryIndexAutoScalingUpdate"}
1845	if v.ProvisionedReadCapacityAutoScalingUpdate != nil {
1846		if err := validateAutoScalingSettingsUpdate(v.ProvisionedReadCapacityAutoScalingUpdate); err != nil {
1847			invalidParams.AddNested("ProvisionedReadCapacityAutoScalingUpdate", err.(smithy.InvalidParamsError))
1848		}
1849	}
1850	if invalidParams.Len() > 0 {
1851		return invalidParams
1852	} else {
1853		return nil
1854	}
1855}
1856
1857func validateReplicaGlobalSecondaryIndexAutoScalingUpdateList(v []types.ReplicaGlobalSecondaryIndexAutoScalingUpdate) error {
1858	if v == nil {
1859		return nil
1860	}
1861	invalidParams := smithy.InvalidParamsError{Context: "ReplicaGlobalSecondaryIndexAutoScalingUpdateList"}
1862	for i := range v {
1863		if err := validateReplicaGlobalSecondaryIndexAutoScalingUpdate(&v[i]); err != nil {
1864			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1865		}
1866	}
1867	if invalidParams.Len() > 0 {
1868		return invalidParams
1869	} else {
1870		return nil
1871	}
1872}
1873
1874func validateReplicaGlobalSecondaryIndexList(v []types.ReplicaGlobalSecondaryIndex) error {
1875	if v == nil {
1876		return nil
1877	}
1878	invalidParams := smithy.InvalidParamsError{Context: "ReplicaGlobalSecondaryIndexList"}
1879	for i := range v {
1880		if err := validateReplicaGlobalSecondaryIndex(&v[i]); err != nil {
1881			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1882		}
1883	}
1884	if invalidParams.Len() > 0 {
1885		return invalidParams
1886	} else {
1887		return nil
1888	}
1889}
1890
1891func validateReplicaGlobalSecondaryIndexSettingsUpdate(v *types.ReplicaGlobalSecondaryIndexSettingsUpdate) error {
1892	if v == nil {
1893		return nil
1894	}
1895	invalidParams := smithy.InvalidParamsError{Context: "ReplicaGlobalSecondaryIndexSettingsUpdate"}
1896	if v.IndexName == nil {
1897		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
1898	}
1899	if v.ProvisionedReadCapacityAutoScalingSettingsUpdate != nil {
1900		if err := validateAutoScalingSettingsUpdate(v.ProvisionedReadCapacityAutoScalingSettingsUpdate); err != nil {
1901			invalidParams.AddNested("ProvisionedReadCapacityAutoScalingSettingsUpdate", err.(smithy.InvalidParamsError))
1902		}
1903	}
1904	if invalidParams.Len() > 0 {
1905		return invalidParams
1906	} else {
1907		return nil
1908	}
1909}
1910
1911func validateReplicaGlobalSecondaryIndexSettingsUpdateList(v []types.ReplicaGlobalSecondaryIndexSettingsUpdate) error {
1912	if v == nil {
1913		return nil
1914	}
1915	invalidParams := smithy.InvalidParamsError{Context: "ReplicaGlobalSecondaryIndexSettingsUpdateList"}
1916	for i := range v {
1917		if err := validateReplicaGlobalSecondaryIndexSettingsUpdate(&v[i]); err != nil {
1918			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1919		}
1920	}
1921	if invalidParams.Len() > 0 {
1922		return invalidParams
1923	} else {
1924		return nil
1925	}
1926}
1927
1928func validateReplicaSettingsUpdate(v *types.ReplicaSettingsUpdate) error {
1929	if v == nil {
1930		return nil
1931	}
1932	invalidParams := smithy.InvalidParamsError{Context: "ReplicaSettingsUpdate"}
1933	if v.RegionName == nil {
1934		invalidParams.Add(smithy.NewErrParamRequired("RegionName"))
1935	}
1936	if v.ReplicaProvisionedReadCapacityAutoScalingSettingsUpdate != nil {
1937		if err := validateAutoScalingSettingsUpdate(v.ReplicaProvisionedReadCapacityAutoScalingSettingsUpdate); err != nil {
1938			invalidParams.AddNested("ReplicaProvisionedReadCapacityAutoScalingSettingsUpdate", err.(smithy.InvalidParamsError))
1939		}
1940	}
1941	if v.ReplicaGlobalSecondaryIndexSettingsUpdate != nil {
1942		if err := validateReplicaGlobalSecondaryIndexSettingsUpdateList(v.ReplicaGlobalSecondaryIndexSettingsUpdate); err != nil {
1943			invalidParams.AddNested("ReplicaGlobalSecondaryIndexSettingsUpdate", err.(smithy.InvalidParamsError))
1944		}
1945	}
1946	if invalidParams.Len() > 0 {
1947		return invalidParams
1948	} else {
1949		return nil
1950	}
1951}
1952
1953func validateReplicaSettingsUpdateList(v []types.ReplicaSettingsUpdate) error {
1954	if v == nil {
1955		return nil
1956	}
1957	invalidParams := smithy.InvalidParamsError{Context: "ReplicaSettingsUpdateList"}
1958	for i := range v {
1959		if err := validateReplicaSettingsUpdate(&v[i]); err != nil {
1960			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
1961		}
1962	}
1963	if invalidParams.Len() > 0 {
1964		return invalidParams
1965	} else {
1966		return nil
1967	}
1968}
1969
1970func validateReplicationGroupUpdate(v *types.ReplicationGroupUpdate) error {
1971	if v == nil {
1972		return nil
1973	}
1974	invalidParams := smithy.InvalidParamsError{Context: "ReplicationGroupUpdate"}
1975	if v.Create != nil {
1976		if err := validateCreateReplicationGroupMemberAction(v.Create); err != nil {
1977			invalidParams.AddNested("Create", err.(smithy.InvalidParamsError))
1978		}
1979	}
1980	if v.Update != nil {
1981		if err := validateUpdateReplicationGroupMemberAction(v.Update); err != nil {
1982			invalidParams.AddNested("Update", err.(smithy.InvalidParamsError))
1983		}
1984	}
1985	if v.Delete != nil {
1986		if err := validateDeleteReplicationGroupMemberAction(v.Delete); err != nil {
1987			invalidParams.AddNested("Delete", err.(smithy.InvalidParamsError))
1988		}
1989	}
1990	if invalidParams.Len() > 0 {
1991		return invalidParams
1992	} else {
1993		return nil
1994	}
1995}
1996
1997func validateReplicationGroupUpdateList(v []types.ReplicationGroupUpdate) error {
1998	if v == nil {
1999		return nil
2000	}
2001	invalidParams := smithy.InvalidParamsError{Context: "ReplicationGroupUpdateList"}
2002	for i := range v {
2003		if err := validateReplicationGroupUpdate(&v[i]); err != nil {
2004			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2005		}
2006	}
2007	if invalidParams.Len() > 0 {
2008		return invalidParams
2009	} else {
2010		return nil
2011	}
2012}
2013
2014func validateReplicaUpdate(v *types.ReplicaUpdate) error {
2015	if v == nil {
2016		return nil
2017	}
2018	invalidParams := smithy.InvalidParamsError{Context: "ReplicaUpdate"}
2019	if v.Create != nil {
2020		if err := validateCreateReplicaAction(v.Create); err != nil {
2021			invalidParams.AddNested("Create", err.(smithy.InvalidParamsError))
2022		}
2023	}
2024	if v.Delete != nil {
2025		if err := validateDeleteReplicaAction(v.Delete); err != nil {
2026			invalidParams.AddNested("Delete", err.(smithy.InvalidParamsError))
2027		}
2028	}
2029	if invalidParams.Len() > 0 {
2030		return invalidParams
2031	} else {
2032		return nil
2033	}
2034}
2035
2036func validateReplicaUpdateList(v []types.ReplicaUpdate) error {
2037	if v == nil {
2038		return nil
2039	}
2040	invalidParams := smithy.InvalidParamsError{Context: "ReplicaUpdateList"}
2041	for i := range v {
2042		if err := validateReplicaUpdate(&v[i]); err != nil {
2043			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2044		}
2045	}
2046	if invalidParams.Len() > 0 {
2047		return invalidParams
2048	} else {
2049		return nil
2050	}
2051}
2052
2053func validateStreamSpecification(v *types.StreamSpecification) error {
2054	if v == nil {
2055		return nil
2056	}
2057	invalidParams := smithy.InvalidParamsError{Context: "StreamSpecification"}
2058	if v.StreamEnabled == nil {
2059		invalidParams.Add(smithy.NewErrParamRequired("StreamEnabled"))
2060	}
2061	if invalidParams.Len() > 0 {
2062		return invalidParams
2063	} else {
2064		return nil
2065	}
2066}
2067
2068func validateTag(v *types.Tag) error {
2069	if v == nil {
2070		return nil
2071	}
2072	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
2073	if v.Key == nil {
2074		invalidParams.Add(smithy.NewErrParamRequired("Key"))
2075	}
2076	if v.Value == nil {
2077		invalidParams.Add(smithy.NewErrParamRequired("Value"))
2078	}
2079	if invalidParams.Len() > 0 {
2080		return invalidParams
2081	} else {
2082		return nil
2083	}
2084}
2085
2086func validateTagList(v []types.Tag) error {
2087	if v == nil {
2088		return nil
2089	}
2090	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
2091	for i := range v {
2092		if err := validateTag(&v[i]); err != nil {
2093			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2094		}
2095	}
2096	if invalidParams.Len() > 0 {
2097		return invalidParams
2098	} else {
2099		return nil
2100	}
2101}
2102
2103func validateTimeToLiveSpecification(v *types.TimeToLiveSpecification) error {
2104	if v == nil {
2105		return nil
2106	}
2107	invalidParams := smithy.InvalidParamsError{Context: "TimeToLiveSpecification"}
2108	if v.Enabled == nil {
2109		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
2110	}
2111	if v.AttributeName == nil {
2112		invalidParams.Add(smithy.NewErrParamRequired("AttributeName"))
2113	}
2114	if invalidParams.Len() > 0 {
2115		return invalidParams
2116	} else {
2117		return nil
2118	}
2119}
2120
2121func validateTransactGetItem(v *types.TransactGetItem) error {
2122	if v == nil {
2123		return nil
2124	}
2125	invalidParams := smithy.InvalidParamsError{Context: "TransactGetItem"}
2126	if v.Get == nil {
2127		invalidParams.Add(smithy.NewErrParamRequired("Get"))
2128	} else if v.Get != nil {
2129		if err := validateGet(v.Get); err != nil {
2130			invalidParams.AddNested("Get", err.(smithy.InvalidParamsError))
2131		}
2132	}
2133	if invalidParams.Len() > 0 {
2134		return invalidParams
2135	} else {
2136		return nil
2137	}
2138}
2139
2140func validateTransactGetItemList(v []types.TransactGetItem) error {
2141	if v == nil {
2142		return nil
2143	}
2144	invalidParams := smithy.InvalidParamsError{Context: "TransactGetItemList"}
2145	for i := range v {
2146		if err := validateTransactGetItem(&v[i]); err != nil {
2147			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2148		}
2149	}
2150	if invalidParams.Len() > 0 {
2151		return invalidParams
2152	} else {
2153		return nil
2154	}
2155}
2156
2157func validateTransactWriteItem(v *types.TransactWriteItem) error {
2158	if v == nil {
2159		return nil
2160	}
2161	invalidParams := smithy.InvalidParamsError{Context: "TransactWriteItem"}
2162	if v.ConditionCheck != nil {
2163		if err := validateConditionCheck(v.ConditionCheck); err != nil {
2164			invalidParams.AddNested("ConditionCheck", err.(smithy.InvalidParamsError))
2165		}
2166	}
2167	if v.Put != nil {
2168		if err := validatePut(v.Put); err != nil {
2169			invalidParams.AddNested("Put", err.(smithy.InvalidParamsError))
2170		}
2171	}
2172	if v.Delete != nil {
2173		if err := validateDelete(v.Delete); err != nil {
2174			invalidParams.AddNested("Delete", err.(smithy.InvalidParamsError))
2175		}
2176	}
2177	if v.Update != nil {
2178		if err := validateUpdate(v.Update); err != nil {
2179			invalidParams.AddNested("Update", err.(smithy.InvalidParamsError))
2180		}
2181	}
2182	if invalidParams.Len() > 0 {
2183		return invalidParams
2184	} else {
2185		return nil
2186	}
2187}
2188
2189func validateTransactWriteItemList(v []types.TransactWriteItem) error {
2190	if v == nil {
2191		return nil
2192	}
2193	invalidParams := smithy.InvalidParamsError{Context: "TransactWriteItemList"}
2194	for i := range v {
2195		if err := validateTransactWriteItem(&v[i]); err != nil {
2196			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2197		}
2198	}
2199	if invalidParams.Len() > 0 {
2200		return invalidParams
2201	} else {
2202		return nil
2203	}
2204}
2205
2206func validateUpdate(v *types.Update) error {
2207	if v == nil {
2208		return nil
2209	}
2210	invalidParams := smithy.InvalidParamsError{Context: "Update"}
2211	if v.Key == nil {
2212		invalidParams.Add(smithy.NewErrParamRequired("Key"))
2213	}
2214	if v.UpdateExpression == nil {
2215		invalidParams.Add(smithy.NewErrParamRequired("UpdateExpression"))
2216	}
2217	if v.TableName == nil {
2218		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2219	}
2220	if invalidParams.Len() > 0 {
2221		return invalidParams
2222	} else {
2223		return nil
2224	}
2225}
2226
2227func validateUpdateGlobalSecondaryIndexAction(v *types.UpdateGlobalSecondaryIndexAction) error {
2228	if v == nil {
2229		return nil
2230	}
2231	invalidParams := smithy.InvalidParamsError{Context: "UpdateGlobalSecondaryIndexAction"}
2232	if v.IndexName == nil {
2233		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
2234	}
2235	if v.ProvisionedThroughput == nil {
2236		invalidParams.Add(smithy.NewErrParamRequired("ProvisionedThroughput"))
2237	} else if v.ProvisionedThroughput != nil {
2238		if err := validateProvisionedThroughput(v.ProvisionedThroughput); err != nil {
2239			invalidParams.AddNested("ProvisionedThroughput", err.(smithy.InvalidParamsError))
2240		}
2241	}
2242	if invalidParams.Len() > 0 {
2243		return invalidParams
2244	} else {
2245		return nil
2246	}
2247}
2248
2249func validateUpdateReplicationGroupMemberAction(v *types.UpdateReplicationGroupMemberAction) error {
2250	if v == nil {
2251		return nil
2252	}
2253	invalidParams := smithy.InvalidParamsError{Context: "UpdateReplicationGroupMemberAction"}
2254	if v.RegionName == nil {
2255		invalidParams.Add(smithy.NewErrParamRequired("RegionName"))
2256	}
2257	if v.GlobalSecondaryIndexes != nil {
2258		if err := validateReplicaGlobalSecondaryIndexList(v.GlobalSecondaryIndexes); err != nil {
2259			invalidParams.AddNested("GlobalSecondaryIndexes", err.(smithy.InvalidParamsError))
2260		}
2261	}
2262	if invalidParams.Len() > 0 {
2263		return invalidParams
2264	} else {
2265		return nil
2266	}
2267}
2268
2269func validateWriteRequest(v *types.WriteRequest) error {
2270	if v == nil {
2271		return nil
2272	}
2273	invalidParams := smithy.InvalidParamsError{Context: "WriteRequest"}
2274	if v.PutRequest != nil {
2275		if err := validatePutRequest(v.PutRequest); err != nil {
2276			invalidParams.AddNested("PutRequest", err.(smithy.InvalidParamsError))
2277		}
2278	}
2279	if v.DeleteRequest != nil {
2280		if err := validateDeleteRequest(v.DeleteRequest); err != nil {
2281			invalidParams.AddNested("DeleteRequest", err.(smithy.InvalidParamsError))
2282		}
2283	}
2284	if invalidParams.Len() > 0 {
2285		return invalidParams
2286	} else {
2287		return nil
2288	}
2289}
2290
2291func validateWriteRequests(v []types.WriteRequest) error {
2292	if v == nil {
2293		return nil
2294	}
2295	invalidParams := smithy.InvalidParamsError{Context: "WriteRequests"}
2296	for i := range v {
2297		if err := validateWriteRequest(&v[i]); err != nil {
2298			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
2299		}
2300	}
2301	if invalidParams.Len() > 0 {
2302		return invalidParams
2303	} else {
2304		return nil
2305	}
2306}
2307
2308func validateOpBatchExecuteStatementInput(v *BatchExecuteStatementInput) error {
2309	if v == nil {
2310		return nil
2311	}
2312	invalidParams := smithy.InvalidParamsError{Context: "BatchExecuteStatementInput"}
2313	if v.Statements == nil {
2314		invalidParams.Add(smithy.NewErrParamRequired("Statements"))
2315	} else if v.Statements != nil {
2316		if err := validatePartiQLBatchRequest(v.Statements); err != nil {
2317			invalidParams.AddNested("Statements", err.(smithy.InvalidParamsError))
2318		}
2319	}
2320	if invalidParams.Len() > 0 {
2321		return invalidParams
2322	} else {
2323		return nil
2324	}
2325}
2326
2327func validateOpBatchGetItemInput(v *BatchGetItemInput) error {
2328	if v == nil {
2329		return nil
2330	}
2331	invalidParams := smithy.InvalidParamsError{Context: "BatchGetItemInput"}
2332	if v.RequestItems == nil {
2333		invalidParams.Add(smithy.NewErrParamRequired("RequestItems"))
2334	} else if v.RequestItems != nil {
2335		if err := validateBatchGetRequestMap(v.RequestItems); err != nil {
2336			invalidParams.AddNested("RequestItems", err.(smithy.InvalidParamsError))
2337		}
2338	}
2339	if invalidParams.Len() > 0 {
2340		return invalidParams
2341	} else {
2342		return nil
2343	}
2344}
2345
2346func validateOpBatchWriteItemInput(v *BatchWriteItemInput) error {
2347	if v == nil {
2348		return nil
2349	}
2350	invalidParams := smithy.InvalidParamsError{Context: "BatchWriteItemInput"}
2351	if v.RequestItems == nil {
2352		invalidParams.Add(smithy.NewErrParamRequired("RequestItems"))
2353	} else if v.RequestItems != nil {
2354		if err := validateBatchWriteItemRequestMap(v.RequestItems); err != nil {
2355			invalidParams.AddNested("RequestItems", err.(smithy.InvalidParamsError))
2356		}
2357	}
2358	if invalidParams.Len() > 0 {
2359		return invalidParams
2360	} else {
2361		return nil
2362	}
2363}
2364
2365func validateOpCreateBackupInput(v *CreateBackupInput) error {
2366	if v == nil {
2367		return nil
2368	}
2369	invalidParams := smithy.InvalidParamsError{Context: "CreateBackupInput"}
2370	if v.TableName == nil {
2371		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2372	}
2373	if v.BackupName == nil {
2374		invalidParams.Add(smithy.NewErrParamRequired("BackupName"))
2375	}
2376	if invalidParams.Len() > 0 {
2377		return invalidParams
2378	} else {
2379		return nil
2380	}
2381}
2382
2383func validateOpCreateGlobalTableInput(v *CreateGlobalTableInput) error {
2384	if v == nil {
2385		return nil
2386	}
2387	invalidParams := smithy.InvalidParamsError{Context: "CreateGlobalTableInput"}
2388	if v.GlobalTableName == nil {
2389		invalidParams.Add(smithy.NewErrParamRequired("GlobalTableName"))
2390	}
2391	if v.ReplicationGroup == nil {
2392		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroup"))
2393	}
2394	if invalidParams.Len() > 0 {
2395		return invalidParams
2396	} else {
2397		return nil
2398	}
2399}
2400
2401func validateOpCreateTableInput(v *CreateTableInput) error {
2402	if v == nil {
2403		return nil
2404	}
2405	invalidParams := smithy.InvalidParamsError{Context: "CreateTableInput"}
2406	if v.AttributeDefinitions == nil {
2407		invalidParams.Add(smithy.NewErrParamRequired("AttributeDefinitions"))
2408	} else if v.AttributeDefinitions != nil {
2409		if err := validateAttributeDefinitions(v.AttributeDefinitions); err != nil {
2410			invalidParams.AddNested("AttributeDefinitions", err.(smithy.InvalidParamsError))
2411		}
2412	}
2413	if v.TableName == nil {
2414		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2415	}
2416	if v.KeySchema == nil {
2417		invalidParams.Add(smithy.NewErrParamRequired("KeySchema"))
2418	} else if v.KeySchema != nil {
2419		if err := validateKeySchema(v.KeySchema); err != nil {
2420			invalidParams.AddNested("KeySchema", err.(smithy.InvalidParamsError))
2421		}
2422	}
2423	if v.LocalSecondaryIndexes != nil {
2424		if err := validateLocalSecondaryIndexList(v.LocalSecondaryIndexes); err != nil {
2425			invalidParams.AddNested("LocalSecondaryIndexes", err.(smithy.InvalidParamsError))
2426		}
2427	}
2428	if v.GlobalSecondaryIndexes != nil {
2429		if err := validateGlobalSecondaryIndexList(v.GlobalSecondaryIndexes); err != nil {
2430			invalidParams.AddNested("GlobalSecondaryIndexes", err.(smithy.InvalidParamsError))
2431		}
2432	}
2433	if v.ProvisionedThroughput != nil {
2434		if err := validateProvisionedThroughput(v.ProvisionedThroughput); err != nil {
2435			invalidParams.AddNested("ProvisionedThroughput", err.(smithy.InvalidParamsError))
2436		}
2437	}
2438	if v.StreamSpecification != nil {
2439		if err := validateStreamSpecification(v.StreamSpecification); err != nil {
2440			invalidParams.AddNested("StreamSpecification", err.(smithy.InvalidParamsError))
2441		}
2442	}
2443	if v.Tags != nil {
2444		if err := validateTagList(v.Tags); err != nil {
2445			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2446		}
2447	}
2448	if invalidParams.Len() > 0 {
2449		return invalidParams
2450	} else {
2451		return nil
2452	}
2453}
2454
2455func validateOpDeleteBackupInput(v *DeleteBackupInput) error {
2456	if v == nil {
2457		return nil
2458	}
2459	invalidParams := smithy.InvalidParamsError{Context: "DeleteBackupInput"}
2460	if v.BackupArn == nil {
2461		invalidParams.Add(smithy.NewErrParamRequired("BackupArn"))
2462	}
2463	if invalidParams.Len() > 0 {
2464		return invalidParams
2465	} else {
2466		return nil
2467	}
2468}
2469
2470func validateOpDeleteItemInput(v *DeleteItemInput) error {
2471	if v == nil {
2472		return nil
2473	}
2474	invalidParams := smithy.InvalidParamsError{Context: "DeleteItemInput"}
2475	if v.TableName == nil {
2476		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2477	}
2478	if v.Key == nil {
2479		invalidParams.Add(smithy.NewErrParamRequired("Key"))
2480	}
2481	if invalidParams.Len() > 0 {
2482		return invalidParams
2483	} else {
2484		return nil
2485	}
2486}
2487
2488func validateOpDeleteTableInput(v *DeleteTableInput) error {
2489	if v == nil {
2490		return nil
2491	}
2492	invalidParams := smithy.InvalidParamsError{Context: "DeleteTableInput"}
2493	if v.TableName == nil {
2494		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2495	}
2496	if invalidParams.Len() > 0 {
2497		return invalidParams
2498	} else {
2499		return nil
2500	}
2501}
2502
2503func validateOpDescribeBackupInput(v *DescribeBackupInput) error {
2504	if v == nil {
2505		return nil
2506	}
2507	invalidParams := smithy.InvalidParamsError{Context: "DescribeBackupInput"}
2508	if v.BackupArn == nil {
2509		invalidParams.Add(smithy.NewErrParamRequired("BackupArn"))
2510	}
2511	if invalidParams.Len() > 0 {
2512		return invalidParams
2513	} else {
2514		return nil
2515	}
2516}
2517
2518func validateOpDescribeContinuousBackupsInput(v *DescribeContinuousBackupsInput) error {
2519	if v == nil {
2520		return nil
2521	}
2522	invalidParams := smithy.InvalidParamsError{Context: "DescribeContinuousBackupsInput"}
2523	if v.TableName == nil {
2524		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2525	}
2526	if invalidParams.Len() > 0 {
2527		return invalidParams
2528	} else {
2529		return nil
2530	}
2531}
2532
2533func validateOpDescribeContributorInsightsInput(v *DescribeContributorInsightsInput) error {
2534	if v == nil {
2535		return nil
2536	}
2537	invalidParams := smithy.InvalidParamsError{Context: "DescribeContributorInsightsInput"}
2538	if v.TableName == nil {
2539		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2540	}
2541	if invalidParams.Len() > 0 {
2542		return invalidParams
2543	} else {
2544		return nil
2545	}
2546}
2547
2548func validateOpDescribeExportInput(v *DescribeExportInput) error {
2549	if v == nil {
2550		return nil
2551	}
2552	invalidParams := smithy.InvalidParamsError{Context: "DescribeExportInput"}
2553	if v.ExportArn == nil {
2554		invalidParams.Add(smithy.NewErrParamRequired("ExportArn"))
2555	}
2556	if invalidParams.Len() > 0 {
2557		return invalidParams
2558	} else {
2559		return nil
2560	}
2561}
2562
2563func validateOpDescribeGlobalTableInput(v *DescribeGlobalTableInput) error {
2564	if v == nil {
2565		return nil
2566	}
2567	invalidParams := smithy.InvalidParamsError{Context: "DescribeGlobalTableInput"}
2568	if v.GlobalTableName == nil {
2569		invalidParams.Add(smithy.NewErrParamRequired("GlobalTableName"))
2570	}
2571	if invalidParams.Len() > 0 {
2572		return invalidParams
2573	} else {
2574		return nil
2575	}
2576}
2577
2578func validateOpDescribeGlobalTableSettingsInput(v *DescribeGlobalTableSettingsInput) error {
2579	if v == nil {
2580		return nil
2581	}
2582	invalidParams := smithy.InvalidParamsError{Context: "DescribeGlobalTableSettingsInput"}
2583	if v.GlobalTableName == nil {
2584		invalidParams.Add(smithy.NewErrParamRequired("GlobalTableName"))
2585	}
2586	if invalidParams.Len() > 0 {
2587		return invalidParams
2588	} else {
2589		return nil
2590	}
2591}
2592
2593func validateOpDescribeKinesisStreamingDestinationInput(v *DescribeKinesisStreamingDestinationInput) error {
2594	if v == nil {
2595		return nil
2596	}
2597	invalidParams := smithy.InvalidParamsError{Context: "DescribeKinesisStreamingDestinationInput"}
2598	if v.TableName == nil {
2599		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2600	}
2601	if invalidParams.Len() > 0 {
2602		return invalidParams
2603	} else {
2604		return nil
2605	}
2606}
2607
2608func validateOpDescribeTableInput(v *DescribeTableInput) error {
2609	if v == nil {
2610		return nil
2611	}
2612	invalidParams := smithy.InvalidParamsError{Context: "DescribeTableInput"}
2613	if v.TableName == nil {
2614		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2615	}
2616	if invalidParams.Len() > 0 {
2617		return invalidParams
2618	} else {
2619		return nil
2620	}
2621}
2622
2623func validateOpDescribeTableReplicaAutoScalingInput(v *DescribeTableReplicaAutoScalingInput) error {
2624	if v == nil {
2625		return nil
2626	}
2627	invalidParams := smithy.InvalidParamsError{Context: "DescribeTableReplicaAutoScalingInput"}
2628	if v.TableName == nil {
2629		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2630	}
2631	if invalidParams.Len() > 0 {
2632		return invalidParams
2633	} else {
2634		return nil
2635	}
2636}
2637
2638func validateOpDescribeTimeToLiveInput(v *DescribeTimeToLiveInput) error {
2639	if v == nil {
2640		return nil
2641	}
2642	invalidParams := smithy.InvalidParamsError{Context: "DescribeTimeToLiveInput"}
2643	if v.TableName == nil {
2644		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2645	}
2646	if invalidParams.Len() > 0 {
2647		return invalidParams
2648	} else {
2649		return nil
2650	}
2651}
2652
2653func validateOpDisableKinesisStreamingDestinationInput(v *DisableKinesisStreamingDestinationInput) error {
2654	if v == nil {
2655		return nil
2656	}
2657	invalidParams := smithy.InvalidParamsError{Context: "DisableKinesisStreamingDestinationInput"}
2658	if v.TableName == nil {
2659		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2660	}
2661	if v.StreamArn == nil {
2662		invalidParams.Add(smithy.NewErrParamRequired("StreamArn"))
2663	}
2664	if invalidParams.Len() > 0 {
2665		return invalidParams
2666	} else {
2667		return nil
2668	}
2669}
2670
2671func validateOpEnableKinesisStreamingDestinationInput(v *EnableKinesisStreamingDestinationInput) error {
2672	if v == nil {
2673		return nil
2674	}
2675	invalidParams := smithy.InvalidParamsError{Context: "EnableKinesisStreamingDestinationInput"}
2676	if v.TableName == nil {
2677		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2678	}
2679	if v.StreamArn == nil {
2680		invalidParams.Add(smithy.NewErrParamRequired("StreamArn"))
2681	}
2682	if invalidParams.Len() > 0 {
2683		return invalidParams
2684	} else {
2685		return nil
2686	}
2687}
2688
2689func validateOpExecuteStatementInput(v *ExecuteStatementInput) error {
2690	if v == nil {
2691		return nil
2692	}
2693	invalidParams := smithy.InvalidParamsError{Context: "ExecuteStatementInput"}
2694	if v.Statement == nil {
2695		invalidParams.Add(smithy.NewErrParamRequired("Statement"))
2696	}
2697	if invalidParams.Len() > 0 {
2698		return invalidParams
2699	} else {
2700		return nil
2701	}
2702}
2703
2704func validateOpExecuteTransactionInput(v *ExecuteTransactionInput) error {
2705	if v == nil {
2706		return nil
2707	}
2708	invalidParams := smithy.InvalidParamsError{Context: "ExecuteTransactionInput"}
2709	if v.TransactStatements == nil {
2710		invalidParams.Add(smithy.NewErrParamRequired("TransactStatements"))
2711	} else if v.TransactStatements != nil {
2712		if err := validateParameterizedStatements(v.TransactStatements); err != nil {
2713			invalidParams.AddNested("TransactStatements", err.(smithy.InvalidParamsError))
2714		}
2715	}
2716	if invalidParams.Len() > 0 {
2717		return invalidParams
2718	} else {
2719		return nil
2720	}
2721}
2722
2723func validateOpExportTableToPointInTimeInput(v *ExportTableToPointInTimeInput) error {
2724	if v == nil {
2725		return nil
2726	}
2727	invalidParams := smithy.InvalidParamsError{Context: "ExportTableToPointInTimeInput"}
2728	if v.TableArn == nil {
2729		invalidParams.Add(smithy.NewErrParamRequired("TableArn"))
2730	}
2731	if v.S3Bucket == nil {
2732		invalidParams.Add(smithy.NewErrParamRequired("S3Bucket"))
2733	}
2734	if invalidParams.Len() > 0 {
2735		return invalidParams
2736	} else {
2737		return nil
2738	}
2739}
2740
2741func validateOpGetItemInput(v *GetItemInput) error {
2742	if v == nil {
2743		return nil
2744	}
2745	invalidParams := smithy.InvalidParamsError{Context: "GetItemInput"}
2746	if v.TableName == nil {
2747		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2748	}
2749	if v.Key == nil {
2750		invalidParams.Add(smithy.NewErrParamRequired("Key"))
2751	}
2752	if invalidParams.Len() > 0 {
2753		return invalidParams
2754	} else {
2755		return nil
2756	}
2757}
2758
2759func validateOpListTagsOfResourceInput(v *ListTagsOfResourceInput) error {
2760	if v == nil {
2761		return nil
2762	}
2763	invalidParams := smithy.InvalidParamsError{Context: "ListTagsOfResourceInput"}
2764	if v.ResourceArn == nil {
2765		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2766	}
2767	if invalidParams.Len() > 0 {
2768		return invalidParams
2769	} else {
2770		return nil
2771	}
2772}
2773
2774func validateOpPutItemInput(v *PutItemInput) error {
2775	if v == nil {
2776		return nil
2777	}
2778	invalidParams := smithy.InvalidParamsError{Context: "PutItemInput"}
2779	if v.TableName == nil {
2780		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2781	}
2782	if v.Item == nil {
2783		invalidParams.Add(smithy.NewErrParamRequired("Item"))
2784	}
2785	if invalidParams.Len() > 0 {
2786		return invalidParams
2787	} else {
2788		return nil
2789	}
2790}
2791
2792func validateOpQueryInput(v *QueryInput) error {
2793	if v == nil {
2794		return nil
2795	}
2796	invalidParams := smithy.InvalidParamsError{Context: "QueryInput"}
2797	if v.TableName == nil {
2798		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2799	}
2800	if v.KeyConditions != nil {
2801		if err := validateKeyConditions(v.KeyConditions); err != nil {
2802			invalidParams.AddNested("KeyConditions", err.(smithy.InvalidParamsError))
2803		}
2804	}
2805	if v.QueryFilter != nil {
2806		if err := validateFilterConditionMap(v.QueryFilter); err != nil {
2807			invalidParams.AddNested("QueryFilter", err.(smithy.InvalidParamsError))
2808		}
2809	}
2810	if invalidParams.Len() > 0 {
2811		return invalidParams
2812	} else {
2813		return nil
2814	}
2815}
2816
2817func validateOpRestoreTableFromBackupInput(v *RestoreTableFromBackupInput) error {
2818	if v == nil {
2819		return nil
2820	}
2821	invalidParams := smithy.InvalidParamsError{Context: "RestoreTableFromBackupInput"}
2822	if v.TargetTableName == nil {
2823		invalidParams.Add(smithy.NewErrParamRequired("TargetTableName"))
2824	}
2825	if v.BackupArn == nil {
2826		invalidParams.Add(smithy.NewErrParamRequired("BackupArn"))
2827	}
2828	if v.GlobalSecondaryIndexOverride != nil {
2829		if err := validateGlobalSecondaryIndexList(v.GlobalSecondaryIndexOverride); err != nil {
2830			invalidParams.AddNested("GlobalSecondaryIndexOverride", err.(smithy.InvalidParamsError))
2831		}
2832	}
2833	if v.LocalSecondaryIndexOverride != nil {
2834		if err := validateLocalSecondaryIndexList(v.LocalSecondaryIndexOverride); err != nil {
2835			invalidParams.AddNested("LocalSecondaryIndexOverride", err.(smithy.InvalidParamsError))
2836		}
2837	}
2838	if v.ProvisionedThroughputOverride != nil {
2839		if err := validateProvisionedThroughput(v.ProvisionedThroughputOverride); err != nil {
2840			invalidParams.AddNested("ProvisionedThroughputOverride", err.(smithy.InvalidParamsError))
2841		}
2842	}
2843	if invalidParams.Len() > 0 {
2844		return invalidParams
2845	} else {
2846		return nil
2847	}
2848}
2849
2850func validateOpRestoreTableToPointInTimeInput(v *RestoreTableToPointInTimeInput) error {
2851	if v == nil {
2852		return nil
2853	}
2854	invalidParams := smithy.InvalidParamsError{Context: "RestoreTableToPointInTimeInput"}
2855	if v.TargetTableName == nil {
2856		invalidParams.Add(smithy.NewErrParamRequired("TargetTableName"))
2857	}
2858	if v.GlobalSecondaryIndexOverride != nil {
2859		if err := validateGlobalSecondaryIndexList(v.GlobalSecondaryIndexOverride); err != nil {
2860			invalidParams.AddNested("GlobalSecondaryIndexOverride", err.(smithy.InvalidParamsError))
2861		}
2862	}
2863	if v.LocalSecondaryIndexOverride != nil {
2864		if err := validateLocalSecondaryIndexList(v.LocalSecondaryIndexOverride); err != nil {
2865			invalidParams.AddNested("LocalSecondaryIndexOverride", err.(smithy.InvalidParamsError))
2866		}
2867	}
2868	if v.ProvisionedThroughputOverride != nil {
2869		if err := validateProvisionedThroughput(v.ProvisionedThroughputOverride); err != nil {
2870			invalidParams.AddNested("ProvisionedThroughputOverride", err.(smithy.InvalidParamsError))
2871		}
2872	}
2873	if invalidParams.Len() > 0 {
2874		return invalidParams
2875	} else {
2876		return nil
2877	}
2878}
2879
2880func validateOpScanInput(v *ScanInput) error {
2881	if v == nil {
2882		return nil
2883	}
2884	invalidParams := smithy.InvalidParamsError{Context: "ScanInput"}
2885	if v.TableName == nil {
2886		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2887	}
2888	if v.ScanFilter != nil {
2889		if err := validateFilterConditionMap(v.ScanFilter); err != nil {
2890			invalidParams.AddNested("ScanFilter", err.(smithy.InvalidParamsError))
2891		}
2892	}
2893	if invalidParams.Len() > 0 {
2894		return invalidParams
2895	} else {
2896		return nil
2897	}
2898}
2899
2900func validateOpTagResourceInput(v *TagResourceInput) error {
2901	if v == nil {
2902		return nil
2903	}
2904	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
2905	if v.ResourceArn == nil {
2906		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2907	}
2908	if v.Tags == nil {
2909		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
2910	} else if v.Tags != nil {
2911		if err := validateTagList(v.Tags); err != nil {
2912			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
2913		}
2914	}
2915	if invalidParams.Len() > 0 {
2916		return invalidParams
2917	} else {
2918		return nil
2919	}
2920}
2921
2922func validateOpTransactGetItemsInput(v *TransactGetItemsInput) error {
2923	if v == nil {
2924		return nil
2925	}
2926	invalidParams := smithy.InvalidParamsError{Context: "TransactGetItemsInput"}
2927	if v.TransactItems == nil {
2928		invalidParams.Add(smithy.NewErrParamRequired("TransactItems"))
2929	} else if v.TransactItems != nil {
2930		if err := validateTransactGetItemList(v.TransactItems); err != nil {
2931			invalidParams.AddNested("TransactItems", err.(smithy.InvalidParamsError))
2932		}
2933	}
2934	if invalidParams.Len() > 0 {
2935		return invalidParams
2936	} else {
2937		return nil
2938	}
2939}
2940
2941func validateOpTransactWriteItemsInput(v *TransactWriteItemsInput) error {
2942	if v == nil {
2943		return nil
2944	}
2945	invalidParams := smithy.InvalidParamsError{Context: "TransactWriteItemsInput"}
2946	if v.TransactItems == nil {
2947		invalidParams.Add(smithy.NewErrParamRequired("TransactItems"))
2948	} else if v.TransactItems != nil {
2949		if err := validateTransactWriteItemList(v.TransactItems); err != nil {
2950			invalidParams.AddNested("TransactItems", err.(smithy.InvalidParamsError))
2951		}
2952	}
2953	if invalidParams.Len() > 0 {
2954		return invalidParams
2955	} else {
2956		return nil
2957	}
2958}
2959
2960func validateOpUntagResourceInput(v *UntagResourceInput) error {
2961	if v == nil {
2962		return nil
2963	}
2964	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
2965	if v.ResourceArn == nil {
2966		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
2967	}
2968	if v.TagKeys == nil {
2969		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
2970	}
2971	if invalidParams.Len() > 0 {
2972		return invalidParams
2973	} else {
2974		return nil
2975	}
2976}
2977
2978func validateOpUpdateContinuousBackupsInput(v *UpdateContinuousBackupsInput) error {
2979	if v == nil {
2980		return nil
2981	}
2982	invalidParams := smithy.InvalidParamsError{Context: "UpdateContinuousBackupsInput"}
2983	if v.TableName == nil {
2984		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
2985	}
2986	if v.PointInTimeRecoverySpecification == nil {
2987		invalidParams.Add(smithy.NewErrParamRequired("PointInTimeRecoverySpecification"))
2988	} else if v.PointInTimeRecoverySpecification != nil {
2989		if err := validatePointInTimeRecoverySpecification(v.PointInTimeRecoverySpecification); err != nil {
2990			invalidParams.AddNested("PointInTimeRecoverySpecification", err.(smithy.InvalidParamsError))
2991		}
2992	}
2993	if invalidParams.Len() > 0 {
2994		return invalidParams
2995	} else {
2996		return nil
2997	}
2998}
2999
3000func validateOpUpdateContributorInsightsInput(v *UpdateContributorInsightsInput) error {
3001	if v == nil {
3002		return nil
3003	}
3004	invalidParams := smithy.InvalidParamsError{Context: "UpdateContributorInsightsInput"}
3005	if v.TableName == nil {
3006		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
3007	}
3008	if len(v.ContributorInsightsAction) == 0 {
3009		invalidParams.Add(smithy.NewErrParamRequired("ContributorInsightsAction"))
3010	}
3011	if invalidParams.Len() > 0 {
3012		return invalidParams
3013	} else {
3014		return nil
3015	}
3016}
3017
3018func validateOpUpdateGlobalTableInput(v *UpdateGlobalTableInput) error {
3019	if v == nil {
3020		return nil
3021	}
3022	invalidParams := smithy.InvalidParamsError{Context: "UpdateGlobalTableInput"}
3023	if v.GlobalTableName == nil {
3024		invalidParams.Add(smithy.NewErrParamRequired("GlobalTableName"))
3025	}
3026	if v.ReplicaUpdates == nil {
3027		invalidParams.Add(smithy.NewErrParamRequired("ReplicaUpdates"))
3028	} else if v.ReplicaUpdates != nil {
3029		if err := validateReplicaUpdateList(v.ReplicaUpdates); err != nil {
3030			invalidParams.AddNested("ReplicaUpdates", err.(smithy.InvalidParamsError))
3031		}
3032	}
3033	if invalidParams.Len() > 0 {
3034		return invalidParams
3035	} else {
3036		return nil
3037	}
3038}
3039
3040func validateOpUpdateGlobalTableSettingsInput(v *UpdateGlobalTableSettingsInput) error {
3041	if v == nil {
3042		return nil
3043	}
3044	invalidParams := smithy.InvalidParamsError{Context: "UpdateGlobalTableSettingsInput"}
3045	if v.GlobalTableName == nil {
3046		invalidParams.Add(smithy.NewErrParamRequired("GlobalTableName"))
3047	}
3048	if v.GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate != nil {
3049		if err := validateAutoScalingSettingsUpdate(v.GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate); err != nil {
3050			invalidParams.AddNested("GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate", err.(smithy.InvalidParamsError))
3051		}
3052	}
3053	if v.GlobalTableGlobalSecondaryIndexSettingsUpdate != nil {
3054		if err := validateGlobalTableGlobalSecondaryIndexSettingsUpdateList(v.GlobalTableGlobalSecondaryIndexSettingsUpdate); err != nil {
3055			invalidParams.AddNested("GlobalTableGlobalSecondaryIndexSettingsUpdate", err.(smithy.InvalidParamsError))
3056		}
3057	}
3058	if v.ReplicaSettingsUpdate != nil {
3059		if err := validateReplicaSettingsUpdateList(v.ReplicaSettingsUpdate); err != nil {
3060			invalidParams.AddNested("ReplicaSettingsUpdate", err.(smithy.InvalidParamsError))
3061		}
3062	}
3063	if invalidParams.Len() > 0 {
3064		return invalidParams
3065	} else {
3066		return nil
3067	}
3068}
3069
3070func validateOpUpdateItemInput(v *UpdateItemInput) error {
3071	if v == nil {
3072		return nil
3073	}
3074	invalidParams := smithy.InvalidParamsError{Context: "UpdateItemInput"}
3075	if v.TableName == nil {
3076		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
3077	}
3078	if v.Key == nil {
3079		invalidParams.Add(smithy.NewErrParamRequired("Key"))
3080	}
3081	if invalidParams.Len() > 0 {
3082		return invalidParams
3083	} else {
3084		return nil
3085	}
3086}
3087
3088func validateOpUpdateTableInput(v *UpdateTableInput) error {
3089	if v == nil {
3090		return nil
3091	}
3092	invalidParams := smithy.InvalidParamsError{Context: "UpdateTableInput"}
3093	if v.AttributeDefinitions != nil {
3094		if err := validateAttributeDefinitions(v.AttributeDefinitions); err != nil {
3095			invalidParams.AddNested("AttributeDefinitions", err.(smithy.InvalidParamsError))
3096		}
3097	}
3098	if v.TableName == nil {
3099		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
3100	}
3101	if v.ProvisionedThroughput != nil {
3102		if err := validateProvisionedThroughput(v.ProvisionedThroughput); err != nil {
3103			invalidParams.AddNested("ProvisionedThroughput", err.(smithy.InvalidParamsError))
3104		}
3105	}
3106	if v.GlobalSecondaryIndexUpdates != nil {
3107		if err := validateGlobalSecondaryIndexUpdateList(v.GlobalSecondaryIndexUpdates); err != nil {
3108			invalidParams.AddNested("GlobalSecondaryIndexUpdates", err.(smithy.InvalidParamsError))
3109		}
3110	}
3111	if v.StreamSpecification != nil {
3112		if err := validateStreamSpecification(v.StreamSpecification); err != nil {
3113			invalidParams.AddNested("StreamSpecification", err.(smithy.InvalidParamsError))
3114		}
3115	}
3116	if v.ReplicaUpdates != nil {
3117		if err := validateReplicationGroupUpdateList(v.ReplicaUpdates); err != nil {
3118			invalidParams.AddNested("ReplicaUpdates", err.(smithy.InvalidParamsError))
3119		}
3120	}
3121	if invalidParams.Len() > 0 {
3122		return invalidParams
3123	} else {
3124		return nil
3125	}
3126}
3127
3128func validateOpUpdateTableReplicaAutoScalingInput(v *UpdateTableReplicaAutoScalingInput) error {
3129	if v == nil {
3130		return nil
3131	}
3132	invalidParams := smithy.InvalidParamsError{Context: "UpdateTableReplicaAutoScalingInput"}
3133	if v.GlobalSecondaryIndexUpdates != nil {
3134		if err := validateGlobalSecondaryIndexAutoScalingUpdateList(v.GlobalSecondaryIndexUpdates); err != nil {
3135			invalidParams.AddNested("GlobalSecondaryIndexUpdates", err.(smithy.InvalidParamsError))
3136		}
3137	}
3138	if v.TableName == nil {
3139		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
3140	}
3141	if v.ProvisionedWriteCapacityAutoScalingUpdate != nil {
3142		if err := validateAutoScalingSettingsUpdate(v.ProvisionedWriteCapacityAutoScalingUpdate); err != nil {
3143			invalidParams.AddNested("ProvisionedWriteCapacityAutoScalingUpdate", err.(smithy.InvalidParamsError))
3144		}
3145	}
3146	if v.ReplicaUpdates != nil {
3147		if err := validateReplicaAutoScalingUpdateList(v.ReplicaUpdates); err != nil {
3148			invalidParams.AddNested("ReplicaUpdates", err.(smithy.InvalidParamsError))
3149		}
3150	}
3151	if invalidParams.Len() > 0 {
3152		return invalidParams
3153	} else {
3154		return nil
3155	}
3156}
3157
3158func validateOpUpdateTimeToLiveInput(v *UpdateTimeToLiveInput) error {
3159	if v == nil {
3160		return nil
3161	}
3162	invalidParams := smithy.InvalidParamsError{Context: "UpdateTimeToLiveInput"}
3163	if v.TableName == nil {
3164		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
3165	}
3166	if v.TimeToLiveSpecification == nil {
3167		invalidParams.Add(smithy.NewErrParamRequired("TimeToLiveSpecification"))
3168	} else if v.TimeToLiveSpecification != nil {
3169		if err := validateTimeToLiveSpecification(v.TimeToLiveSpecification); err != nil {
3170			invalidParams.AddNested("TimeToLiveSpecification", err.(smithy.InvalidParamsError))
3171		}
3172	}
3173	if invalidParams.Len() > 0 {
3174		return invalidParams
3175	} else {
3176		return nil
3177	}
3178}
3179