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