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