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