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 validateOpAuthorizeClusterSecurityGroupIngress struct { 34} 35 36func (*validateOpAuthorizeClusterSecurityGroupIngress) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpAuthorizeClusterSecurityGroupIngress) 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.(*AuthorizeClusterSecurityGroupIngressInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpAuthorizeClusterSecurityGroupIngressInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpAuthorizeSnapshotAccess struct { 54} 55 56func (*validateOpAuthorizeSnapshotAccess) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpAuthorizeSnapshotAccess) 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.(*AuthorizeSnapshotAccessInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpAuthorizeSnapshotAccessInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpBatchDeleteClusterSnapshots struct { 74} 75 76func (*validateOpBatchDeleteClusterSnapshots) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpBatchDeleteClusterSnapshots) 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.(*BatchDeleteClusterSnapshotsInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpBatchDeleteClusterSnapshotsInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpBatchModifyClusterSnapshots struct { 94} 95 96func (*validateOpBatchModifyClusterSnapshots) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpBatchModifyClusterSnapshots) 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.(*BatchModifyClusterSnapshotsInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpBatchModifyClusterSnapshotsInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCancelResize struct { 114} 115 116func (*validateOpCancelResize) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCancelResize) 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.(*CancelResizeInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCancelResizeInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpCopyClusterSnapshot struct { 134} 135 136func (*validateOpCopyClusterSnapshot) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpCopyClusterSnapshot) 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.(*CopyClusterSnapshotInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpCopyClusterSnapshotInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpCreateCluster struct { 154} 155 156func (*validateOpCreateCluster) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpCreateCluster) 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.(*CreateClusterInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpCreateClusterInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpCreateClusterParameterGroup struct { 174} 175 176func (*validateOpCreateClusterParameterGroup) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpCreateClusterParameterGroup) 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.(*CreateClusterParameterGroupInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpCreateClusterParameterGroupInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpCreateClusterSecurityGroup struct { 194} 195 196func (*validateOpCreateClusterSecurityGroup) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpCreateClusterSecurityGroup) 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.(*CreateClusterSecurityGroupInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpCreateClusterSecurityGroupInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpCreateClusterSnapshot struct { 214} 215 216func (*validateOpCreateClusterSnapshot) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpCreateClusterSnapshot) 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.(*CreateClusterSnapshotInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpCreateClusterSnapshotInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpCreateClusterSubnetGroup struct { 234} 235 236func (*validateOpCreateClusterSubnetGroup) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpCreateClusterSubnetGroup) 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.(*CreateClusterSubnetGroupInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpCreateClusterSubnetGroupInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpCreateEventSubscription struct { 254} 255 256func (*validateOpCreateEventSubscription) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpCreateEventSubscription) 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.(*CreateEventSubscriptionInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpCreateEventSubscriptionInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpCreateHsmClientCertificate struct { 274} 275 276func (*validateOpCreateHsmClientCertificate) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpCreateHsmClientCertificate) 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.(*CreateHsmClientCertificateInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpCreateHsmClientCertificateInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpCreateHsmConfiguration struct { 294} 295 296func (*validateOpCreateHsmConfiguration) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpCreateHsmConfiguration) 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.(*CreateHsmConfigurationInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpCreateHsmConfigurationInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpCreateScheduledAction struct { 314} 315 316func (*validateOpCreateScheduledAction) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpCreateScheduledAction) 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.(*CreateScheduledActionInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpCreateScheduledActionInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpCreateSnapshotCopyGrant struct { 334} 335 336func (*validateOpCreateSnapshotCopyGrant) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpCreateSnapshotCopyGrant) 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.(*CreateSnapshotCopyGrantInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpCreateSnapshotCopyGrantInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpCreateTags struct { 354} 355 356func (*validateOpCreateTags) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpCreateTags) 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.(*CreateTagsInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpCreateTagsInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpCreateUsageLimit struct { 374} 375 376func (*validateOpCreateUsageLimit) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpCreateUsageLimit) 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.(*CreateUsageLimitInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpCreateUsageLimitInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpDeleteCluster struct { 394} 395 396func (*validateOpDeleteCluster) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpDeleteCluster) 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.(*DeleteClusterInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpDeleteClusterInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpDeleteClusterParameterGroup struct { 414} 415 416func (*validateOpDeleteClusterParameterGroup) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpDeleteClusterParameterGroup) 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.(*DeleteClusterParameterGroupInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpDeleteClusterParameterGroupInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpDeleteClusterSecurityGroup struct { 434} 435 436func (*validateOpDeleteClusterSecurityGroup) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpDeleteClusterSecurityGroup) 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.(*DeleteClusterSecurityGroupInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpDeleteClusterSecurityGroupInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpDeleteClusterSnapshot struct { 454} 455 456func (*validateOpDeleteClusterSnapshot) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpDeleteClusterSnapshot) 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.(*DeleteClusterSnapshotInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpDeleteClusterSnapshotInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpDeleteClusterSubnetGroup struct { 474} 475 476func (*validateOpDeleteClusterSubnetGroup) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpDeleteClusterSubnetGroup) 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.(*DeleteClusterSubnetGroupInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpDeleteClusterSubnetGroupInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpDeleteEventSubscription struct { 494} 495 496func (*validateOpDeleteEventSubscription) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpDeleteEventSubscription) 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.(*DeleteEventSubscriptionInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpDeleteEventSubscriptionInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpDeleteHsmClientCertificate struct { 514} 515 516func (*validateOpDeleteHsmClientCertificate) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpDeleteHsmClientCertificate) 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.(*DeleteHsmClientCertificateInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpDeleteHsmClientCertificateInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpDeleteHsmConfiguration struct { 534} 535 536func (*validateOpDeleteHsmConfiguration) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpDeleteHsmConfiguration) 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.(*DeleteHsmConfigurationInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpDeleteHsmConfigurationInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpDeleteScheduledAction struct { 554} 555 556func (*validateOpDeleteScheduledAction) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpDeleteScheduledAction) 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.(*DeleteScheduledActionInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpDeleteScheduledActionInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpDeleteSnapshotCopyGrant struct { 574} 575 576func (*validateOpDeleteSnapshotCopyGrant) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpDeleteSnapshotCopyGrant) 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.(*DeleteSnapshotCopyGrantInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpDeleteSnapshotCopyGrantInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpDeleteSnapshotSchedule struct { 594} 595 596func (*validateOpDeleteSnapshotSchedule) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpDeleteSnapshotSchedule) 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.(*DeleteSnapshotScheduleInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpDeleteSnapshotScheduleInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpDeleteTags struct { 614} 615 616func (*validateOpDeleteTags) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpDeleteTags) 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.(*DeleteTagsInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpDeleteTagsInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpDeleteUsageLimit struct { 634} 635 636func (*validateOpDeleteUsageLimit) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpDeleteUsageLimit) 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.(*DeleteUsageLimitInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpDeleteUsageLimitInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpDescribeClusterParameters struct { 654} 655 656func (*validateOpDescribeClusterParameters) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpDescribeClusterParameters) 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.(*DescribeClusterParametersInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpDescribeClusterParametersInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpDescribeClusterSnapshots struct { 674} 675 676func (*validateOpDescribeClusterSnapshots) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpDescribeClusterSnapshots) 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.(*DescribeClusterSnapshotsInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpDescribeClusterSnapshotsInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpDescribeDefaultClusterParameters struct { 694} 695 696func (*validateOpDescribeDefaultClusterParameters) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpDescribeDefaultClusterParameters) 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.(*DescribeDefaultClusterParametersInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpDescribeDefaultClusterParametersInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpDescribeLoggingStatus struct { 714} 715 716func (*validateOpDescribeLoggingStatus) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpDescribeLoggingStatus) 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.(*DescribeLoggingStatusInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpDescribeLoggingStatusInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpDescribeNodeConfigurationOptions struct { 734} 735 736func (*validateOpDescribeNodeConfigurationOptions) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpDescribeNodeConfigurationOptions) 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.(*DescribeNodeConfigurationOptionsInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpDescribeNodeConfigurationOptionsInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753type validateOpDescribeResize struct { 754} 755 756func (*validateOpDescribeResize) ID() string { 757 return "OperationInputValidation" 758} 759 760func (m *validateOpDescribeResize) 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.(*DescribeResizeInput) 764 if !ok { 765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 766 } 767 if err := validateOpDescribeResizeInput(input); err != nil { 768 return out, metadata, err 769 } 770 return next.HandleInitialize(ctx, in) 771} 772 773type validateOpDescribeScheduledActions struct { 774} 775 776func (*validateOpDescribeScheduledActions) ID() string { 777 return "OperationInputValidation" 778} 779 780func (m *validateOpDescribeScheduledActions) 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.(*DescribeScheduledActionsInput) 784 if !ok { 785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 786 } 787 if err := validateOpDescribeScheduledActionsInput(input); err != nil { 788 return out, metadata, err 789 } 790 return next.HandleInitialize(ctx, in) 791} 792 793type validateOpDisableLogging struct { 794} 795 796func (*validateOpDisableLogging) ID() string { 797 return "OperationInputValidation" 798} 799 800func (m *validateOpDisableLogging) 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.(*DisableLoggingInput) 804 if !ok { 805 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 806 } 807 if err := validateOpDisableLoggingInput(input); err != nil { 808 return out, metadata, err 809 } 810 return next.HandleInitialize(ctx, in) 811} 812 813type validateOpDisableSnapshotCopy struct { 814} 815 816func (*validateOpDisableSnapshotCopy) ID() string { 817 return "OperationInputValidation" 818} 819 820func (m *validateOpDisableSnapshotCopy) 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.(*DisableSnapshotCopyInput) 824 if !ok { 825 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 826 } 827 if err := validateOpDisableSnapshotCopyInput(input); err != nil { 828 return out, metadata, err 829 } 830 return next.HandleInitialize(ctx, in) 831} 832 833type validateOpEnableLogging struct { 834} 835 836func (*validateOpEnableLogging) ID() string { 837 return "OperationInputValidation" 838} 839 840func (m *validateOpEnableLogging) 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.(*EnableLoggingInput) 844 if !ok { 845 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 846 } 847 if err := validateOpEnableLoggingInput(input); err != nil { 848 return out, metadata, err 849 } 850 return next.HandleInitialize(ctx, in) 851} 852 853type validateOpEnableSnapshotCopy struct { 854} 855 856func (*validateOpEnableSnapshotCopy) ID() string { 857 return "OperationInputValidation" 858} 859 860func (m *validateOpEnableSnapshotCopy) 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.(*EnableSnapshotCopyInput) 864 if !ok { 865 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 866 } 867 if err := validateOpEnableSnapshotCopyInput(input); err != nil { 868 return out, metadata, err 869 } 870 return next.HandleInitialize(ctx, in) 871} 872 873type validateOpGetClusterCredentials struct { 874} 875 876func (*validateOpGetClusterCredentials) ID() string { 877 return "OperationInputValidation" 878} 879 880func (m *validateOpGetClusterCredentials) 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.(*GetClusterCredentialsInput) 884 if !ok { 885 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 886 } 887 if err := validateOpGetClusterCredentialsInput(input); err != nil { 888 return out, metadata, err 889 } 890 return next.HandleInitialize(ctx, in) 891} 892 893type validateOpGetReservedNodeExchangeOfferings struct { 894} 895 896func (*validateOpGetReservedNodeExchangeOfferings) ID() string { 897 return "OperationInputValidation" 898} 899 900func (m *validateOpGetReservedNodeExchangeOfferings) 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.(*GetReservedNodeExchangeOfferingsInput) 904 if !ok { 905 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 906 } 907 if err := validateOpGetReservedNodeExchangeOfferingsInput(input); err != nil { 908 return out, metadata, err 909 } 910 return next.HandleInitialize(ctx, in) 911} 912 913type validateOpModifyClusterDbRevision struct { 914} 915 916func (*validateOpModifyClusterDbRevision) ID() string { 917 return "OperationInputValidation" 918} 919 920func (m *validateOpModifyClusterDbRevision) 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.(*ModifyClusterDbRevisionInput) 924 if !ok { 925 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 926 } 927 if err := validateOpModifyClusterDbRevisionInput(input); err != nil { 928 return out, metadata, err 929 } 930 return next.HandleInitialize(ctx, in) 931} 932 933type validateOpModifyClusterIamRoles struct { 934} 935 936func (*validateOpModifyClusterIamRoles) ID() string { 937 return "OperationInputValidation" 938} 939 940func (m *validateOpModifyClusterIamRoles) 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.(*ModifyClusterIamRolesInput) 944 if !ok { 945 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 946 } 947 if err := validateOpModifyClusterIamRolesInput(input); err != nil { 948 return out, metadata, err 949 } 950 return next.HandleInitialize(ctx, in) 951} 952 953type validateOpModifyCluster struct { 954} 955 956func (*validateOpModifyCluster) ID() string { 957 return "OperationInputValidation" 958} 959 960func (m *validateOpModifyCluster) 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.(*ModifyClusterInput) 964 if !ok { 965 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 966 } 967 if err := validateOpModifyClusterInput(input); err != nil { 968 return out, metadata, err 969 } 970 return next.HandleInitialize(ctx, in) 971} 972 973type validateOpModifyClusterMaintenance struct { 974} 975 976func (*validateOpModifyClusterMaintenance) ID() string { 977 return "OperationInputValidation" 978} 979 980func (m *validateOpModifyClusterMaintenance) 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.(*ModifyClusterMaintenanceInput) 984 if !ok { 985 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 986 } 987 if err := validateOpModifyClusterMaintenanceInput(input); err != nil { 988 return out, metadata, err 989 } 990 return next.HandleInitialize(ctx, in) 991} 992 993type validateOpModifyClusterParameterGroup struct { 994} 995 996func (*validateOpModifyClusterParameterGroup) ID() string { 997 return "OperationInputValidation" 998} 999 1000func (m *validateOpModifyClusterParameterGroup) 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.(*ModifyClusterParameterGroupInput) 1004 if !ok { 1005 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1006 } 1007 if err := validateOpModifyClusterParameterGroupInput(input); err != nil { 1008 return out, metadata, err 1009 } 1010 return next.HandleInitialize(ctx, in) 1011} 1012 1013type validateOpModifyClusterSnapshot struct { 1014} 1015 1016func (*validateOpModifyClusterSnapshot) ID() string { 1017 return "OperationInputValidation" 1018} 1019 1020func (m *validateOpModifyClusterSnapshot) 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.(*ModifyClusterSnapshotInput) 1024 if !ok { 1025 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1026 } 1027 if err := validateOpModifyClusterSnapshotInput(input); err != nil { 1028 return out, metadata, err 1029 } 1030 return next.HandleInitialize(ctx, in) 1031} 1032 1033type validateOpModifyClusterSnapshotSchedule struct { 1034} 1035 1036func (*validateOpModifyClusterSnapshotSchedule) ID() string { 1037 return "OperationInputValidation" 1038} 1039 1040func (m *validateOpModifyClusterSnapshotSchedule) 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.(*ModifyClusterSnapshotScheduleInput) 1044 if !ok { 1045 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1046 } 1047 if err := validateOpModifyClusterSnapshotScheduleInput(input); err != nil { 1048 return out, metadata, err 1049 } 1050 return next.HandleInitialize(ctx, in) 1051} 1052 1053type validateOpModifyClusterSubnetGroup struct { 1054} 1055 1056func (*validateOpModifyClusterSubnetGroup) ID() string { 1057 return "OperationInputValidation" 1058} 1059 1060func (m *validateOpModifyClusterSubnetGroup) 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.(*ModifyClusterSubnetGroupInput) 1064 if !ok { 1065 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1066 } 1067 if err := validateOpModifyClusterSubnetGroupInput(input); err != nil { 1068 return out, metadata, err 1069 } 1070 return next.HandleInitialize(ctx, in) 1071} 1072 1073type validateOpModifyEventSubscription struct { 1074} 1075 1076func (*validateOpModifyEventSubscription) ID() string { 1077 return "OperationInputValidation" 1078} 1079 1080func (m *validateOpModifyEventSubscription) 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.(*ModifyEventSubscriptionInput) 1084 if !ok { 1085 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1086 } 1087 if err := validateOpModifyEventSubscriptionInput(input); err != nil { 1088 return out, metadata, err 1089 } 1090 return next.HandleInitialize(ctx, in) 1091} 1092 1093type validateOpModifyScheduledAction struct { 1094} 1095 1096func (*validateOpModifyScheduledAction) ID() string { 1097 return "OperationInputValidation" 1098} 1099 1100func (m *validateOpModifyScheduledAction) 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.(*ModifyScheduledActionInput) 1104 if !ok { 1105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1106 } 1107 if err := validateOpModifyScheduledActionInput(input); err != nil { 1108 return out, metadata, err 1109 } 1110 return next.HandleInitialize(ctx, in) 1111} 1112 1113type validateOpModifySnapshotCopyRetentionPeriod struct { 1114} 1115 1116func (*validateOpModifySnapshotCopyRetentionPeriod) ID() string { 1117 return "OperationInputValidation" 1118} 1119 1120func (m *validateOpModifySnapshotCopyRetentionPeriod) 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.(*ModifySnapshotCopyRetentionPeriodInput) 1124 if !ok { 1125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1126 } 1127 if err := validateOpModifySnapshotCopyRetentionPeriodInput(input); err != nil { 1128 return out, metadata, err 1129 } 1130 return next.HandleInitialize(ctx, in) 1131} 1132 1133type validateOpModifySnapshotSchedule struct { 1134} 1135 1136func (*validateOpModifySnapshotSchedule) ID() string { 1137 return "OperationInputValidation" 1138} 1139 1140func (m *validateOpModifySnapshotSchedule) 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.(*ModifySnapshotScheduleInput) 1144 if !ok { 1145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1146 } 1147 if err := validateOpModifySnapshotScheduleInput(input); err != nil { 1148 return out, metadata, err 1149 } 1150 return next.HandleInitialize(ctx, in) 1151} 1152 1153type validateOpModifyUsageLimit struct { 1154} 1155 1156func (*validateOpModifyUsageLimit) ID() string { 1157 return "OperationInputValidation" 1158} 1159 1160func (m *validateOpModifyUsageLimit) 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.(*ModifyUsageLimitInput) 1164 if !ok { 1165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1166 } 1167 if err := validateOpModifyUsageLimitInput(input); err != nil { 1168 return out, metadata, err 1169 } 1170 return next.HandleInitialize(ctx, in) 1171} 1172 1173type validateOpPauseCluster struct { 1174} 1175 1176func (*validateOpPauseCluster) ID() string { 1177 return "OperationInputValidation" 1178} 1179 1180func (m *validateOpPauseCluster) 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.(*PauseClusterInput) 1184 if !ok { 1185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1186 } 1187 if err := validateOpPauseClusterInput(input); err != nil { 1188 return out, metadata, err 1189 } 1190 return next.HandleInitialize(ctx, in) 1191} 1192 1193type validateOpPurchaseReservedNodeOffering struct { 1194} 1195 1196func (*validateOpPurchaseReservedNodeOffering) ID() string { 1197 return "OperationInputValidation" 1198} 1199 1200func (m *validateOpPurchaseReservedNodeOffering) 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.(*PurchaseReservedNodeOfferingInput) 1204 if !ok { 1205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1206 } 1207 if err := validateOpPurchaseReservedNodeOfferingInput(input); err != nil { 1208 return out, metadata, err 1209 } 1210 return next.HandleInitialize(ctx, in) 1211} 1212 1213type validateOpRebootCluster struct { 1214} 1215 1216func (*validateOpRebootCluster) ID() string { 1217 return "OperationInputValidation" 1218} 1219 1220func (m *validateOpRebootCluster) 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.(*RebootClusterInput) 1224 if !ok { 1225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1226 } 1227 if err := validateOpRebootClusterInput(input); err != nil { 1228 return out, metadata, err 1229 } 1230 return next.HandleInitialize(ctx, in) 1231} 1232 1233type validateOpResetClusterParameterGroup struct { 1234} 1235 1236func (*validateOpResetClusterParameterGroup) ID() string { 1237 return "OperationInputValidation" 1238} 1239 1240func (m *validateOpResetClusterParameterGroup) 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.(*ResetClusterParameterGroupInput) 1244 if !ok { 1245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1246 } 1247 if err := validateOpResetClusterParameterGroupInput(input); err != nil { 1248 return out, metadata, err 1249 } 1250 return next.HandleInitialize(ctx, in) 1251} 1252 1253type validateOpResizeCluster struct { 1254} 1255 1256func (*validateOpResizeCluster) ID() string { 1257 return "OperationInputValidation" 1258} 1259 1260func (m *validateOpResizeCluster) 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.(*ResizeClusterInput) 1264 if !ok { 1265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1266 } 1267 if err := validateOpResizeClusterInput(input); err != nil { 1268 return out, metadata, err 1269 } 1270 return next.HandleInitialize(ctx, in) 1271} 1272 1273type validateOpRestoreFromClusterSnapshot struct { 1274} 1275 1276func (*validateOpRestoreFromClusterSnapshot) ID() string { 1277 return "OperationInputValidation" 1278} 1279 1280func (m *validateOpRestoreFromClusterSnapshot) 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.(*RestoreFromClusterSnapshotInput) 1284 if !ok { 1285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1286 } 1287 if err := validateOpRestoreFromClusterSnapshotInput(input); err != nil { 1288 return out, metadata, err 1289 } 1290 return next.HandleInitialize(ctx, in) 1291} 1292 1293type validateOpRestoreTableFromClusterSnapshot struct { 1294} 1295 1296func (*validateOpRestoreTableFromClusterSnapshot) ID() string { 1297 return "OperationInputValidation" 1298} 1299 1300func (m *validateOpRestoreTableFromClusterSnapshot) 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.(*RestoreTableFromClusterSnapshotInput) 1304 if !ok { 1305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1306 } 1307 if err := validateOpRestoreTableFromClusterSnapshotInput(input); err != nil { 1308 return out, metadata, err 1309 } 1310 return next.HandleInitialize(ctx, in) 1311} 1312 1313type validateOpResumeCluster struct { 1314} 1315 1316func (*validateOpResumeCluster) ID() string { 1317 return "OperationInputValidation" 1318} 1319 1320func (m *validateOpResumeCluster) 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.(*ResumeClusterInput) 1324 if !ok { 1325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1326 } 1327 if err := validateOpResumeClusterInput(input); err != nil { 1328 return out, metadata, err 1329 } 1330 return next.HandleInitialize(ctx, in) 1331} 1332 1333type validateOpRevokeClusterSecurityGroupIngress struct { 1334} 1335 1336func (*validateOpRevokeClusterSecurityGroupIngress) ID() string { 1337 return "OperationInputValidation" 1338} 1339 1340func (m *validateOpRevokeClusterSecurityGroupIngress) 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.(*RevokeClusterSecurityGroupIngressInput) 1344 if !ok { 1345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1346 } 1347 if err := validateOpRevokeClusterSecurityGroupIngressInput(input); err != nil { 1348 return out, metadata, err 1349 } 1350 return next.HandleInitialize(ctx, in) 1351} 1352 1353type validateOpRevokeSnapshotAccess struct { 1354} 1355 1356func (*validateOpRevokeSnapshotAccess) ID() string { 1357 return "OperationInputValidation" 1358} 1359 1360func (m *validateOpRevokeSnapshotAccess) 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.(*RevokeSnapshotAccessInput) 1364 if !ok { 1365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1366 } 1367 if err := validateOpRevokeSnapshotAccessInput(input); err != nil { 1368 return out, metadata, err 1369 } 1370 return next.HandleInitialize(ctx, in) 1371} 1372 1373type validateOpRotateEncryptionKey struct { 1374} 1375 1376func (*validateOpRotateEncryptionKey) ID() string { 1377 return "OperationInputValidation" 1378} 1379 1380func (m *validateOpRotateEncryptionKey) 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.(*RotateEncryptionKeyInput) 1384 if !ok { 1385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1386 } 1387 if err := validateOpRotateEncryptionKeyInput(input); err != nil { 1388 return out, metadata, err 1389 } 1390 return next.HandleInitialize(ctx, in) 1391} 1392 1393func addOpAcceptReservedNodeExchangeValidationMiddleware(stack *middleware.Stack) error { 1394 return stack.Initialize.Add(&validateOpAcceptReservedNodeExchange{}, middleware.After) 1395} 1396 1397func addOpAuthorizeClusterSecurityGroupIngressValidationMiddleware(stack *middleware.Stack) error { 1398 return stack.Initialize.Add(&validateOpAuthorizeClusterSecurityGroupIngress{}, middleware.After) 1399} 1400 1401func addOpAuthorizeSnapshotAccessValidationMiddleware(stack *middleware.Stack) error { 1402 return stack.Initialize.Add(&validateOpAuthorizeSnapshotAccess{}, middleware.After) 1403} 1404 1405func addOpBatchDeleteClusterSnapshotsValidationMiddleware(stack *middleware.Stack) error { 1406 return stack.Initialize.Add(&validateOpBatchDeleteClusterSnapshots{}, middleware.After) 1407} 1408 1409func addOpBatchModifyClusterSnapshotsValidationMiddleware(stack *middleware.Stack) error { 1410 return stack.Initialize.Add(&validateOpBatchModifyClusterSnapshots{}, middleware.After) 1411} 1412 1413func addOpCancelResizeValidationMiddleware(stack *middleware.Stack) error { 1414 return stack.Initialize.Add(&validateOpCancelResize{}, middleware.After) 1415} 1416 1417func addOpCopyClusterSnapshotValidationMiddleware(stack *middleware.Stack) error { 1418 return stack.Initialize.Add(&validateOpCopyClusterSnapshot{}, middleware.After) 1419} 1420 1421func addOpCreateClusterValidationMiddleware(stack *middleware.Stack) error { 1422 return stack.Initialize.Add(&validateOpCreateCluster{}, middleware.After) 1423} 1424 1425func addOpCreateClusterParameterGroupValidationMiddleware(stack *middleware.Stack) error { 1426 return stack.Initialize.Add(&validateOpCreateClusterParameterGroup{}, middleware.After) 1427} 1428 1429func addOpCreateClusterSecurityGroupValidationMiddleware(stack *middleware.Stack) error { 1430 return stack.Initialize.Add(&validateOpCreateClusterSecurityGroup{}, middleware.After) 1431} 1432 1433func addOpCreateClusterSnapshotValidationMiddleware(stack *middleware.Stack) error { 1434 return stack.Initialize.Add(&validateOpCreateClusterSnapshot{}, middleware.After) 1435} 1436 1437func addOpCreateClusterSubnetGroupValidationMiddleware(stack *middleware.Stack) error { 1438 return stack.Initialize.Add(&validateOpCreateClusterSubnetGroup{}, middleware.After) 1439} 1440 1441func addOpCreateEventSubscriptionValidationMiddleware(stack *middleware.Stack) error { 1442 return stack.Initialize.Add(&validateOpCreateEventSubscription{}, middleware.After) 1443} 1444 1445func addOpCreateHsmClientCertificateValidationMiddleware(stack *middleware.Stack) error { 1446 return stack.Initialize.Add(&validateOpCreateHsmClientCertificate{}, middleware.After) 1447} 1448 1449func addOpCreateHsmConfigurationValidationMiddleware(stack *middleware.Stack) error { 1450 return stack.Initialize.Add(&validateOpCreateHsmConfiguration{}, middleware.After) 1451} 1452 1453func addOpCreateScheduledActionValidationMiddleware(stack *middleware.Stack) error { 1454 return stack.Initialize.Add(&validateOpCreateScheduledAction{}, middleware.After) 1455} 1456 1457func addOpCreateSnapshotCopyGrantValidationMiddleware(stack *middleware.Stack) error { 1458 return stack.Initialize.Add(&validateOpCreateSnapshotCopyGrant{}, middleware.After) 1459} 1460 1461func addOpCreateTagsValidationMiddleware(stack *middleware.Stack) error { 1462 return stack.Initialize.Add(&validateOpCreateTags{}, middleware.After) 1463} 1464 1465func addOpCreateUsageLimitValidationMiddleware(stack *middleware.Stack) error { 1466 return stack.Initialize.Add(&validateOpCreateUsageLimit{}, middleware.After) 1467} 1468 1469func addOpDeleteClusterValidationMiddleware(stack *middleware.Stack) error { 1470 return stack.Initialize.Add(&validateOpDeleteCluster{}, middleware.After) 1471} 1472 1473func addOpDeleteClusterParameterGroupValidationMiddleware(stack *middleware.Stack) error { 1474 return stack.Initialize.Add(&validateOpDeleteClusterParameterGroup{}, middleware.After) 1475} 1476 1477func addOpDeleteClusterSecurityGroupValidationMiddleware(stack *middleware.Stack) error { 1478 return stack.Initialize.Add(&validateOpDeleteClusterSecurityGroup{}, middleware.After) 1479} 1480 1481func addOpDeleteClusterSnapshotValidationMiddleware(stack *middleware.Stack) error { 1482 return stack.Initialize.Add(&validateOpDeleteClusterSnapshot{}, middleware.After) 1483} 1484 1485func addOpDeleteClusterSubnetGroupValidationMiddleware(stack *middleware.Stack) error { 1486 return stack.Initialize.Add(&validateOpDeleteClusterSubnetGroup{}, middleware.After) 1487} 1488 1489func addOpDeleteEventSubscriptionValidationMiddleware(stack *middleware.Stack) error { 1490 return stack.Initialize.Add(&validateOpDeleteEventSubscription{}, middleware.After) 1491} 1492 1493func addOpDeleteHsmClientCertificateValidationMiddleware(stack *middleware.Stack) error { 1494 return stack.Initialize.Add(&validateOpDeleteHsmClientCertificate{}, middleware.After) 1495} 1496 1497func addOpDeleteHsmConfigurationValidationMiddleware(stack *middleware.Stack) error { 1498 return stack.Initialize.Add(&validateOpDeleteHsmConfiguration{}, middleware.After) 1499} 1500 1501func addOpDeleteScheduledActionValidationMiddleware(stack *middleware.Stack) error { 1502 return stack.Initialize.Add(&validateOpDeleteScheduledAction{}, middleware.After) 1503} 1504 1505func addOpDeleteSnapshotCopyGrantValidationMiddleware(stack *middleware.Stack) error { 1506 return stack.Initialize.Add(&validateOpDeleteSnapshotCopyGrant{}, middleware.After) 1507} 1508 1509func addOpDeleteSnapshotScheduleValidationMiddleware(stack *middleware.Stack) error { 1510 return stack.Initialize.Add(&validateOpDeleteSnapshotSchedule{}, middleware.After) 1511} 1512 1513func addOpDeleteTagsValidationMiddleware(stack *middleware.Stack) error { 1514 return stack.Initialize.Add(&validateOpDeleteTags{}, middleware.After) 1515} 1516 1517func addOpDeleteUsageLimitValidationMiddleware(stack *middleware.Stack) error { 1518 return stack.Initialize.Add(&validateOpDeleteUsageLimit{}, middleware.After) 1519} 1520 1521func addOpDescribeClusterParametersValidationMiddleware(stack *middleware.Stack) error { 1522 return stack.Initialize.Add(&validateOpDescribeClusterParameters{}, middleware.After) 1523} 1524 1525func addOpDescribeClusterSnapshotsValidationMiddleware(stack *middleware.Stack) error { 1526 return stack.Initialize.Add(&validateOpDescribeClusterSnapshots{}, middleware.After) 1527} 1528 1529func addOpDescribeDefaultClusterParametersValidationMiddleware(stack *middleware.Stack) error { 1530 return stack.Initialize.Add(&validateOpDescribeDefaultClusterParameters{}, middleware.After) 1531} 1532 1533func addOpDescribeLoggingStatusValidationMiddleware(stack *middleware.Stack) error { 1534 return stack.Initialize.Add(&validateOpDescribeLoggingStatus{}, middleware.After) 1535} 1536 1537func addOpDescribeNodeConfigurationOptionsValidationMiddleware(stack *middleware.Stack) error { 1538 return stack.Initialize.Add(&validateOpDescribeNodeConfigurationOptions{}, middleware.After) 1539} 1540 1541func addOpDescribeResizeValidationMiddleware(stack *middleware.Stack) error { 1542 return stack.Initialize.Add(&validateOpDescribeResize{}, middleware.After) 1543} 1544 1545func addOpDescribeScheduledActionsValidationMiddleware(stack *middleware.Stack) error { 1546 return stack.Initialize.Add(&validateOpDescribeScheduledActions{}, middleware.After) 1547} 1548 1549func addOpDisableLoggingValidationMiddleware(stack *middleware.Stack) error { 1550 return stack.Initialize.Add(&validateOpDisableLogging{}, middleware.After) 1551} 1552 1553func addOpDisableSnapshotCopyValidationMiddleware(stack *middleware.Stack) error { 1554 return stack.Initialize.Add(&validateOpDisableSnapshotCopy{}, middleware.After) 1555} 1556 1557func addOpEnableLoggingValidationMiddleware(stack *middleware.Stack) error { 1558 return stack.Initialize.Add(&validateOpEnableLogging{}, middleware.After) 1559} 1560 1561func addOpEnableSnapshotCopyValidationMiddleware(stack *middleware.Stack) error { 1562 return stack.Initialize.Add(&validateOpEnableSnapshotCopy{}, middleware.After) 1563} 1564 1565func addOpGetClusterCredentialsValidationMiddleware(stack *middleware.Stack) error { 1566 return stack.Initialize.Add(&validateOpGetClusterCredentials{}, middleware.After) 1567} 1568 1569func addOpGetReservedNodeExchangeOfferingsValidationMiddleware(stack *middleware.Stack) error { 1570 return stack.Initialize.Add(&validateOpGetReservedNodeExchangeOfferings{}, middleware.After) 1571} 1572 1573func addOpModifyClusterDbRevisionValidationMiddleware(stack *middleware.Stack) error { 1574 return stack.Initialize.Add(&validateOpModifyClusterDbRevision{}, middleware.After) 1575} 1576 1577func addOpModifyClusterIamRolesValidationMiddleware(stack *middleware.Stack) error { 1578 return stack.Initialize.Add(&validateOpModifyClusterIamRoles{}, middleware.After) 1579} 1580 1581func addOpModifyClusterValidationMiddleware(stack *middleware.Stack) error { 1582 return stack.Initialize.Add(&validateOpModifyCluster{}, middleware.After) 1583} 1584 1585func addOpModifyClusterMaintenanceValidationMiddleware(stack *middleware.Stack) error { 1586 return stack.Initialize.Add(&validateOpModifyClusterMaintenance{}, middleware.After) 1587} 1588 1589func addOpModifyClusterParameterGroupValidationMiddleware(stack *middleware.Stack) error { 1590 return stack.Initialize.Add(&validateOpModifyClusterParameterGroup{}, middleware.After) 1591} 1592 1593func addOpModifyClusterSnapshotValidationMiddleware(stack *middleware.Stack) error { 1594 return stack.Initialize.Add(&validateOpModifyClusterSnapshot{}, middleware.After) 1595} 1596 1597func addOpModifyClusterSnapshotScheduleValidationMiddleware(stack *middleware.Stack) error { 1598 return stack.Initialize.Add(&validateOpModifyClusterSnapshotSchedule{}, middleware.After) 1599} 1600 1601func addOpModifyClusterSubnetGroupValidationMiddleware(stack *middleware.Stack) error { 1602 return stack.Initialize.Add(&validateOpModifyClusterSubnetGroup{}, middleware.After) 1603} 1604 1605func addOpModifyEventSubscriptionValidationMiddleware(stack *middleware.Stack) error { 1606 return stack.Initialize.Add(&validateOpModifyEventSubscription{}, middleware.After) 1607} 1608 1609func addOpModifyScheduledActionValidationMiddleware(stack *middleware.Stack) error { 1610 return stack.Initialize.Add(&validateOpModifyScheduledAction{}, middleware.After) 1611} 1612 1613func addOpModifySnapshotCopyRetentionPeriodValidationMiddleware(stack *middleware.Stack) error { 1614 return stack.Initialize.Add(&validateOpModifySnapshotCopyRetentionPeriod{}, middleware.After) 1615} 1616 1617func addOpModifySnapshotScheduleValidationMiddleware(stack *middleware.Stack) error { 1618 return stack.Initialize.Add(&validateOpModifySnapshotSchedule{}, middleware.After) 1619} 1620 1621func addOpModifyUsageLimitValidationMiddleware(stack *middleware.Stack) error { 1622 return stack.Initialize.Add(&validateOpModifyUsageLimit{}, middleware.After) 1623} 1624 1625func addOpPauseClusterValidationMiddleware(stack *middleware.Stack) error { 1626 return stack.Initialize.Add(&validateOpPauseCluster{}, middleware.After) 1627} 1628 1629func addOpPurchaseReservedNodeOfferingValidationMiddleware(stack *middleware.Stack) error { 1630 return stack.Initialize.Add(&validateOpPurchaseReservedNodeOffering{}, middleware.After) 1631} 1632 1633func addOpRebootClusterValidationMiddleware(stack *middleware.Stack) error { 1634 return stack.Initialize.Add(&validateOpRebootCluster{}, middleware.After) 1635} 1636 1637func addOpResetClusterParameterGroupValidationMiddleware(stack *middleware.Stack) error { 1638 return stack.Initialize.Add(&validateOpResetClusterParameterGroup{}, middleware.After) 1639} 1640 1641func addOpResizeClusterValidationMiddleware(stack *middleware.Stack) error { 1642 return stack.Initialize.Add(&validateOpResizeCluster{}, middleware.After) 1643} 1644 1645func addOpRestoreFromClusterSnapshotValidationMiddleware(stack *middleware.Stack) error { 1646 return stack.Initialize.Add(&validateOpRestoreFromClusterSnapshot{}, middleware.After) 1647} 1648 1649func addOpRestoreTableFromClusterSnapshotValidationMiddleware(stack *middleware.Stack) error { 1650 return stack.Initialize.Add(&validateOpRestoreTableFromClusterSnapshot{}, middleware.After) 1651} 1652 1653func addOpResumeClusterValidationMiddleware(stack *middleware.Stack) error { 1654 return stack.Initialize.Add(&validateOpResumeCluster{}, middleware.After) 1655} 1656 1657func addOpRevokeClusterSecurityGroupIngressValidationMiddleware(stack *middleware.Stack) error { 1658 return stack.Initialize.Add(&validateOpRevokeClusterSecurityGroupIngress{}, middleware.After) 1659} 1660 1661func addOpRevokeSnapshotAccessValidationMiddleware(stack *middleware.Stack) error { 1662 return stack.Initialize.Add(&validateOpRevokeSnapshotAccess{}, middleware.After) 1663} 1664 1665func addOpRotateEncryptionKeyValidationMiddleware(stack *middleware.Stack) error { 1666 return stack.Initialize.Add(&validateOpRotateEncryptionKey{}, middleware.After) 1667} 1668 1669func validateDeleteClusterSnapshotMessage(v *types.DeleteClusterSnapshotMessage) error { 1670 if v == nil { 1671 return nil 1672 } 1673 invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterSnapshotMessage"} 1674 if v.SnapshotIdentifier == nil { 1675 invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier")) 1676 } 1677 if invalidParams.Len() > 0 { 1678 return invalidParams 1679 } else { 1680 return nil 1681 } 1682} 1683 1684func validateDeleteClusterSnapshotMessageList(v []types.DeleteClusterSnapshotMessage) error { 1685 if v == nil { 1686 return nil 1687 } 1688 invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterSnapshotMessageList"} 1689 for i := range v { 1690 if err := validateDeleteClusterSnapshotMessage(&v[i]); err != nil { 1691 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1692 } 1693 } 1694 if invalidParams.Len() > 0 { 1695 return invalidParams 1696 } else { 1697 return nil 1698 } 1699} 1700 1701func validatePauseClusterMessage(v *types.PauseClusterMessage) error { 1702 if v == nil { 1703 return nil 1704 } 1705 invalidParams := smithy.InvalidParamsError{Context: "PauseClusterMessage"} 1706 if v.ClusterIdentifier == nil { 1707 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 1708 } 1709 if invalidParams.Len() > 0 { 1710 return invalidParams 1711 } else { 1712 return nil 1713 } 1714} 1715 1716func validateResizeClusterMessage(v *types.ResizeClusterMessage) error { 1717 if v == nil { 1718 return nil 1719 } 1720 invalidParams := smithy.InvalidParamsError{Context: "ResizeClusterMessage"} 1721 if v.ClusterIdentifier == nil { 1722 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 1723 } 1724 if invalidParams.Len() > 0 { 1725 return invalidParams 1726 } else { 1727 return nil 1728 } 1729} 1730 1731func validateResumeClusterMessage(v *types.ResumeClusterMessage) error { 1732 if v == nil { 1733 return nil 1734 } 1735 invalidParams := smithy.InvalidParamsError{Context: "ResumeClusterMessage"} 1736 if v.ClusterIdentifier == nil { 1737 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 1738 } 1739 if invalidParams.Len() > 0 { 1740 return invalidParams 1741 } else { 1742 return nil 1743 } 1744} 1745 1746func validateScheduledActionFilter(v *types.ScheduledActionFilter) error { 1747 if v == nil { 1748 return nil 1749 } 1750 invalidParams := smithy.InvalidParamsError{Context: "ScheduledActionFilter"} 1751 if len(v.Name) == 0 { 1752 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1753 } 1754 if v.Values == nil { 1755 invalidParams.Add(smithy.NewErrParamRequired("Values")) 1756 } 1757 if invalidParams.Len() > 0 { 1758 return invalidParams 1759 } else { 1760 return nil 1761 } 1762} 1763 1764func validateScheduledActionFilterList(v []types.ScheduledActionFilter) error { 1765 if v == nil { 1766 return nil 1767 } 1768 invalidParams := smithy.InvalidParamsError{Context: "ScheduledActionFilterList"} 1769 for i := range v { 1770 if err := validateScheduledActionFilter(&v[i]); err != nil { 1771 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1772 } 1773 } 1774 if invalidParams.Len() > 0 { 1775 return invalidParams 1776 } else { 1777 return nil 1778 } 1779} 1780 1781func validateScheduledActionType(v *types.ScheduledActionType) error { 1782 if v == nil { 1783 return nil 1784 } 1785 invalidParams := smithy.InvalidParamsError{Context: "ScheduledActionType"} 1786 if v.ResizeCluster != nil { 1787 if err := validateResizeClusterMessage(v.ResizeCluster); err != nil { 1788 invalidParams.AddNested("ResizeCluster", err.(smithy.InvalidParamsError)) 1789 } 1790 } 1791 if v.PauseCluster != nil { 1792 if err := validatePauseClusterMessage(v.PauseCluster); err != nil { 1793 invalidParams.AddNested("PauseCluster", err.(smithy.InvalidParamsError)) 1794 } 1795 } 1796 if v.ResumeCluster != nil { 1797 if err := validateResumeClusterMessage(v.ResumeCluster); err != nil { 1798 invalidParams.AddNested("ResumeCluster", err.(smithy.InvalidParamsError)) 1799 } 1800 } 1801 if invalidParams.Len() > 0 { 1802 return invalidParams 1803 } else { 1804 return nil 1805 } 1806} 1807 1808func validateSnapshotSortingEntity(v *types.SnapshotSortingEntity) error { 1809 if v == nil { 1810 return nil 1811 } 1812 invalidParams := smithy.InvalidParamsError{Context: "SnapshotSortingEntity"} 1813 if len(v.Attribute) == 0 { 1814 invalidParams.Add(smithy.NewErrParamRequired("Attribute")) 1815 } 1816 if invalidParams.Len() > 0 { 1817 return invalidParams 1818 } else { 1819 return nil 1820 } 1821} 1822 1823func validateSnapshotSortingEntityList(v []types.SnapshotSortingEntity) error { 1824 if v == nil { 1825 return nil 1826 } 1827 invalidParams := smithy.InvalidParamsError{Context: "SnapshotSortingEntityList"} 1828 for i := range v { 1829 if err := validateSnapshotSortingEntity(&v[i]); err != nil { 1830 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1831 } 1832 } 1833 if invalidParams.Len() > 0 { 1834 return invalidParams 1835 } else { 1836 return nil 1837 } 1838} 1839 1840func validateOpAcceptReservedNodeExchangeInput(v *AcceptReservedNodeExchangeInput) error { 1841 if v == nil { 1842 return nil 1843 } 1844 invalidParams := smithy.InvalidParamsError{Context: "AcceptReservedNodeExchangeInput"} 1845 if v.ReservedNodeId == nil { 1846 invalidParams.Add(smithy.NewErrParamRequired("ReservedNodeId")) 1847 } 1848 if v.TargetReservedNodeOfferingId == nil { 1849 invalidParams.Add(smithy.NewErrParamRequired("TargetReservedNodeOfferingId")) 1850 } 1851 if invalidParams.Len() > 0 { 1852 return invalidParams 1853 } else { 1854 return nil 1855 } 1856} 1857 1858func validateOpAuthorizeClusterSecurityGroupIngressInput(v *AuthorizeClusterSecurityGroupIngressInput) error { 1859 if v == nil { 1860 return nil 1861 } 1862 invalidParams := smithy.InvalidParamsError{Context: "AuthorizeClusterSecurityGroupIngressInput"} 1863 if v.ClusterSecurityGroupName == nil { 1864 invalidParams.Add(smithy.NewErrParamRequired("ClusterSecurityGroupName")) 1865 } 1866 if invalidParams.Len() > 0 { 1867 return invalidParams 1868 } else { 1869 return nil 1870 } 1871} 1872 1873func validateOpAuthorizeSnapshotAccessInput(v *AuthorizeSnapshotAccessInput) error { 1874 if v == nil { 1875 return nil 1876 } 1877 invalidParams := smithy.InvalidParamsError{Context: "AuthorizeSnapshotAccessInput"} 1878 if v.SnapshotIdentifier == nil { 1879 invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier")) 1880 } 1881 if v.AccountWithRestoreAccess == nil { 1882 invalidParams.Add(smithy.NewErrParamRequired("AccountWithRestoreAccess")) 1883 } 1884 if invalidParams.Len() > 0 { 1885 return invalidParams 1886 } else { 1887 return nil 1888 } 1889} 1890 1891func validateOpBatchDeleteClusterSnapshotsInput(v *BatchDeleteClusterSnapshotsInput) error { 1892 if v == nil { 1893 return nil 1894 } 1895 invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteClusterSnapshotsInput"} 1896 if v.Identifiers == nil { 1897 invalidParams.Add(smithy.NewErrParamRequired("Identifiers")) 1898 } else if v.Identifiers != nil { 1899 if err := validateDeleteClusterSnapshotMessageList(v.Identifiers); err != nil { 1900 invalidParams.AddNested("Identifiers", err.(smithy.InvalidParamsError)) 1901 } 1902 } 1903 if invalidParams.Len() > 0 { 1904 return invalidParams 1905 } else { 1906 return nil 1907 } 1908} 1909 1910func validateOpBatchModifyClusterSnapshotsInput(v *BatchModifyClusterSnapshotsInput) error { 1911 if v == nil { 1912 return nil 1913 } 1914 invalidParams := smithy.InvalidParamsError{Context: "BatchModifyClusterSnapshotsInput"} 1915 if v.SnapshotIdentifierList == nil { 1916 invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifierList")) 1917 } 1918 if invalidParams.Len() > 0 { 1919 return invalidParams 1920 } else { 1921 return nil 1922 } 1923} 1924 1925func validateOpCancelResizeInput(v *CancelResizeInput) error { 1926 if v == nil { 1927 return nil 1928 } 1929 invalidParams := smithy.InvalidParamsError{Context: "CancelResizeInput"} 1930 if v.ClusterIdentifier == nil { 1931 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 1932 } 1933 if invalidParams.Len() > 0 { 1934 return invalidParams 1935 } else { 1936 return nil 1937 } 1938} 1939 1940func validateOpCopyClusterSnapshotInput(v *CopyClusterSnapshotInput) error { 1941 if v == nil { 1942 return nil 1943 } 1944 invalidParams := smithy.InvalidParamsError{Context: "CopyClusterSnapshotInput"} 1945 if v.SourceSnapshotIdentifier == nil { 1946 invalidParams.Add(smithy.NewErrParamRequired("SourceSnapshotIdentifier")) 1947 } 1948 if v.TargetSnapshotIdentifier == nil { 1949 invalidParams.Add(smithy.NewErrParamRequired("TargetSnapshotIdentifier")) 1950 } 1951 if invalidParams.Len() > 0 { 1952 return invalidParams 1953 } else { 1954 return nil 1955 } 1956} 1957 1958func validateOpCreateClusterInput(v *CreateClusterInput) error { 1959 if v == nil { 1960 return nil 1961 } 1962 invalidParams := smithy.InvalidParamsError{Context: "CreateClusterInput"} 1963 if v.ClusterIdentifier == nil { 1964 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 1965 } 1966 if v.NodeType == nil { 1967 invalidParams.Add(smithy.NewErrParamRequired("NodeType")) 1968 } 1969 if v.MasterUsername == nil { 1970 invalidParams.Add(smithy.NewErrParamRequired("MasterUsername")) 1971 } 1972 if v.MasterUserPassword == nil { 1973 invalidParams.Add(smithy.NewErrParamRequired("MasterUserPassword")) 1974 } 1975 if invalidParams.Len() > 0 { 1976 return invalidParams 1977 } else { 1978 return nil 1979 } 1980} 1981 1982func validateOpCreateClusterParameterGroupInput(v *CreateClusterParameterGroupInput) error { 1983 if v == nil { 1984 return nil 1985 } 1986 invalidParams := smithy.InvalidParamsError{Context: "CreateClusterParameterGroupInput"} 1987 if v.ParameterGroupName == nil { 1988 invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName")) 1989 } 1990 if v.ParameterGroupFamily == nil { 1991 invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupFamily")) 1992 } 1993 if v.Description == nil { 1994 invalidParams.Add(smithy.NewErrParamRequired("Description")) 1995 } 1996 if invalidParams.Len() > 0 { 1997 return invalidParams 1998 } else { 1999 return nil 2000 } 2001} 2002 2003func validateOpCreateClusterSecurityGroupInput(v *CreateClusterSecurityGroupInput) error { 2004 if v == nil { 2005 return nil 2006 } 2007 invalidParams := smithy.InvalidParamsError{Context: "CreateClusterSecurityGroupInput"} 2008 if v.ClusterSecurityGroupName == nil { 2009 invalidParams.Add(smithy.NewErrParamRequired("ClusterSecurityGroupName")) 2010 } 2011 if v.Description == nil { 2012 invalidParams.Add(smithy.NewErrParamRequired("Description")) 2013 } 2014 if invalidParams.Len() > 0 { 2015 return invalidParams 2016 } else { 2017 return nil 2018 } 2019} 2020 2021func validateOpCreateClusterSnapshotInput(v *CreateClusterSnapshotInput) error { 2022 if v == nil { 2023 return nil 2024 } 2025 invalidParams := smithy.InvalidParamsError{Context: "CreateClusterSnapshotInput"} 2026 if v.SnapshotIdentifier == nil { 2027 invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier")) 2028 } 2029 if v.ClusterIdentifier == nil { 2030 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2031 } 2032 if invalidParams.Len() > 0 { 2033 return invalidParams 2034 } else { 2035 return nil 2036 } 2037} 2038 2039func validateOpCreateClusterSubnetGroupInput(v *CreateClusterSubnetGroupInput) error { 2040 if v == nil { 2041 return nil 2042 } 2043 invalidParams := smithy.InvalidParamsError{Context: "CreateClusterSubnetGroupInput"} 2044 if v.ClusterSubnetGroupName == nil { 2045 invalidParams.Add(smithy.NewErrParamRequired("ClusterSubnetGroupName")) 2046 } 2047 if v.Description == nil { 2048 invalidParams.Add(smithy.NewErrParamRequired("Description")) 2049 } 2050 if v.SubnetIds == nil { 2051 invalidParams.Add(smithy.NewErrParamRequired("SubnetIds")) 2052 } 2053 if invalidParams.Len() > 0 { 2054 return invalidParams 2055 } else { 2056 return nil 2057 } 2058} 2059 2060func validateOpCreateEventSubscriptionInput(v *CreateEventSubscriptionInput) error { 2061 if v == nil { 2062 return nil 2063 } 2064 invalidParams := smithy.InvalidParamsError{Context: "CreateEventSubscriptionInput"} 2065 if v.SubscriptionName == nil { 2066 invalidParams.Add(smithy.NewErrParamRequired("SubscriptionName")) 2067 } 2068 if v.SnsTopicArn == nil { 2069 invalidParams.Add(smithy.NewErrParamRequired("SnsTopicArn")) 2070 } 2071 if invalidParams.Len() > 0 { 2072 return invalidParams 2073 } else { 2074 return nil 2075 } 2076} 2077 2078func validateOpCreateHsmClientCertificateInput(v *CreateHsmClientCertificateInput) error { 2079 if v == nil { 2080 return nil 2081 } 2082 invalidParams := smithy.InvalidParamsError{Context: "CreateHsmClientCertificateInput"} 2083 if v.HsmClientCertificateIdentifier == nil { 2084 invalidParams.Add(smithy.NewErrParamRequired("HsmClientCertificateIdentifier")) 2085 } 2086 if invalidParams.Len() > 0 { 2087 return invalidParams 2088 } else { 2089 return nil 2090 } 2091} 2092 2093func validateOpCreateHsmConfigurationInput(v *CreateHsmConfigurationInput) error { 2094 if v == nil { 2095 return nil 2096 } 2097 invalidParams := smithy.InvalidParamsError{Context: "CreateHsmConfigurationInput"} 2098 if v.HsmConfigurationIdentifier == nil { 2099 invalidParams.Add(smithy.NewErrParamRequired("HsmConfigurationIdentifier")) 2100 } 2101 if v.Description == nil { 2102 invalidParams.Add(smithy.NewErrParamRequired("Description")) 2103 } 2104 if v.HsmIpAddress == nil { 2105 invalidParams.Add(smithy.NewErrParamRequired("HsmIpAddress")) 2106 } 2107 if v.HsmPartitionName == nil { 2108 invalidParams.Add(smithy.NewErrParamRequired("HsmPartitionName")) 2109 } 2110 if v.HsmPartitionPassword == nil { 2111 invalidParams.Add(smithy.NewErrParamRequired("HsmPartitionPassword")) 2112 } 2113 if v.HsmServerPublicCertificate == nil { 2114 invalidParams.Add(smithy.NewErrParamRequired("HsmServerPublicCertificate")) 2115 } 2116 if invalidParams.Len() > 0 { 2117 return invalidParams 2118 } else { 2119 return nil 2120 } 2121} 2122 2123func validateOpCreateScheduledActionInput(v *CreateScheduledActionInput) error { 2124 if v == nil { 2125 return nil 2126 } 2127 invalidParams := smithy.InvalidParamsError{Context: "CreateScheduledActionInput"} 2128 if v.ScheduledActionName == nil { 2129 invalidParams.Add(smithy.NewErrParamRequired("ScheduledActionName")) 2130 } 2131 if v.TargetAction == nil { 2132 invalidParams.Add(smithy.NewErrParamRequired("TargetAction")) 2133 } else if v.TargetAction != nil { 2134 if err := validateScheduledActionType(v.TargetAction); err != nil { 2135 invalidParams.AddNested("TargetAction", err.(smithy.InvalidParamsError)) 2136 } 2137 } 2138 if v.Schedule == nil { 2139 invalidParams.Add(smithy.NewErrParamRequired("Schedule")) 2140 } 2141 if v.IamRole == nil { 2142 invalidParams.Add(smithy.NewErrParamRequired("IamRole")) 2143 } 2144 if invalidParams.Len() > 0 { 2145 return invalidParams 2146 } else { 2147 return nil 2148 } 2149} 2150 2151func validateOpCreateSnapshotCopyGrantInput(v *CreateSnapshotCopyGrantInput) error { 2152 if v == nil { 2153 return nil 2154 } 2155 invalidParams := smithy.InvalidParamsError{Context: "CreateSnapshotCopyGrantInput"} 2156 if v.SnapshotCopyGrantName == nil { 2157 invalidParams.Add(smithy.NewErrParamRequired("SnapshotCopyGrantName")) 2158 } 2159 if invalidParams.Len() > 0 { 2160 return invalidParams 2161 } else { 2162 return nil 2163 } 2164} 2165 2166func validateOpCreateTagsInput(v *CreateTagsInput) error { 2167 if v == nil { 2168 return nil 2169 } 2170 invalidParams := smithy.InvalidParamsError{Context: "CreateTagsInput"} 2171 if v.ResourceName == nil { 2172 invalidParams.Add(smithy.NewErrParamRequired("ResourceName")) 2173 } 2174 if v.Tags == nil { 2175 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 2176 } 2177 if invalidParams.Len() > 0 { 2178 return invalidParams 2179 } else { 2180 return nil 2181 } 2182} 2183 2184func validateOpCreateUsageLimitInput(v *CreateUsageLimitInput) error { 2185 if v == nil { 2186 return nil 2187 } 2188 invalidParams := smithy.InvalidParamsError{Context: "CreateUsageLimitInput"} 2189 if v.ClusterIdentifier == nil { 2190 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2191 } 2192 if len(v.FeatureType) == 0 { 2193 invalidParams.Add(smithy.NewErrParamRequired("FeatureType")) 2194 } 2195 if len(v.LimitType) == 0 { 2196 invalidParams.Add(smithy.NewErrParamRequired("LimitType")) 2197 } 2198 if invalidParams.Len() > 0 { 2199 return invalidParams 2200 } else { 2201 return nil 2202 } 2203} 2204 2205func validateOpDeleteClusterInput(v *DeleteClusterInput) error { 2206 if v == nil { 2207 return nil 2208 } 2209 invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterInput"} 2210 if v.ClusterIdentifier == nil { 2211 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2212 } 2213 if invalidParams.Len() > 0 { 2214 return invalidParams 2215 } else { 2216 return nil 2217 } 2218} 2219 2220func validateOpDeleteClusterParameterGroupInput(v *DeleteClusterParameterGroupInput) error { 2221 if v == nil { 2222 return nil 2223 } 2224 invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterParameterGroupInput"} 2225 if v.ParameterGroupName == nil { 2226 invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName")) 2227 } 2228 if invalidParams.Len() > 0 { 2229 return invalidParams 2230 } else { 2231 return nil 2232 } 2233} 2234 2235func validateOpDeleteClusterSecurityGroupInput(v *DeleteClusterSecurityGroupInput) error { 2236 if v == nil { 2237 return nil 2238 } 2239 invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterSecurityGroupInput"} 2240 if v.ClusterSecurityGroupName == nil { 2241 invalidParams.Add(smithy.NewErrParamRequired("ClusterSecurityGroupName")) 2242 } 2243 if invalidParams.Len() > 0 { 2244 return invalidParams 2245 } else { 2246 return nil 2247 } 2248} 2249 2250func validateOpDeleteClusterSnapshotInput(v *DeleteClusterSnapshotInput) error { 2251 if v == nil { 2252 return nil 2253 } 2254 invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterSnapshotInput"} 2255 if v.SnapshotIdentifier == nil { 2256 invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier")) 2257 } 2258 if invalidParams.Len() > 0 { 2259 return invalidParams 2260 } else { 2261 return nil 2262 } 2263} 2264 2265func validateOpDeleteClusterSubnetGroupInput(v *DeleteClusterSubnetGroupInput) error { 2266 if v == nil { 2267 return nil 2268 } 2269 invalidParams := smithy.InvalidParamsError{Context: "DeleteClusterSubnetGroupInput"} 2270 if v.ClusterSubnetGroupName == nil { 2271 invalidParams.Add(smithy.NewErrParamRequired("ClusterSubnetGroupName")) 2272 } 2273 if invalidParams.Len() > 0 { 2274 return invalidParams 2275 } else { 2276 return nil 2277 } 2278} 2279 2280func validateOpDeleteEventSubscriptionInput(v *DeleteEventSubscriptionInput) error { 2281 if v == nil { 2282 return nil 2283 } 2284 invalidParams := smithy.InvalidParamsError{Context: "DeleteEventSubscriptionInput"} 2285 if v.SubscriptionName == nil { 2286 invalidParams.Add(smithy.NewErrParamRequired("SubscriptionName")) 2287 } 2288 if invalidParams.Len() > 0 { 2289 return invalidParams 2290 } else { 2291 return nil 2292 } 2293} 2294 2295func validateOpDeleteHsmClientCertificateInput(v *DeleteHsmClientCertificateInput) error { 2296 if v == nil { 2297 return nil 2298 } 2299 invalidParams := smithy.InvalidParamsError{Context: "DeleteHsmClientCertificateInput"} 2300 if v.HsmClientCertificateIdentifier == nil { 2301 invalidParams.Add(smithy.NewErrParamRequired("HsmClientCertificateIdentifier")) 2302 } 2303 if invalidParams.Len() > 0 { 2304 return invalidParams 2305 } else { 2306 return nil 2307 } 2308} 2309 2310func validateOpDeleteHsmConfigurationInput(v *DeleteHsmConfigurationInput) error { 2311 if v == nil { 2312 return nil 2313 } 2314 invalidParams := smithy.InvalidParamsError{Context: "DeleteHsmConfigurationInput"} 2315 if v.HsmConfigurationIdentifier == nil { 2316 invalidParams.Add(smithy.NewErrParamRequired("HsmConfigurationIdentifier")) 2317 } 2318 if invalidParams.Len() > 0 { 2319 return invalidParams 2320 } else { 2321 return nil 2322 } 2323} 2324 2325func validateOpDeleteScheduledActionInput(v *DeleteScheduledActionInput) error { 2326 if v == nil { 2327 return nil 2328 } 2329 invalidParams := smithy.InvalidParamsError{Context: "DeleteScheduledActionInput"} 2330 if v.ScheduledActionName == nil { 2331 invalidParams.Add(smithy.NewErrParamRequired("ScheduledActionName")) 2332 } 2333 if invalidParams.Len() > 0 { 2334 return invalidParams 2335 } else { 2336 return nil 2337 } 2338} 2339 2340func validateOpDeleteSnapshotCopyGrantInput(v *DeleteSnapshotCopyGrantInput) error { 2341 if v == nil { 2342 return nil 2343 } 2344 invalidParams := smithy.InvalidParamsError{Context: "DeleteSnapshotCopyGrantInput"} 2345 if v.SnapshotCopyGrantName == nil { 2346 invalidParams.Add(smithy.NewErrParamRequired("SnapshotCopyGrantName")) 2347 } 2348 if invalidParams.Len() > 0 { 2349 return invalidParams 2350 } else { 2351 return nil 2352 } 2353} 2354 2355func validateOpDeleteSnapshotScheduleInput(v *DeleteSnapshotScheduleInput) error { 2356 if v == nil { 2357 return nil 2358 } 2359 invalidParams := smithy.InvalidParamsError{Context: "DeleteSnapshotScheduleInput"} 2360 if v.ScheduleIdentifier == nil { 2361 invalidParams.Add(smithy.NewErrParamRequired("ScheduleIdentifier")) 2362 } 2363 if invalidParams.Len() > 0 { 2364 return invalidParams 2365 } else { 2366 return nil 2367 } 2368} 2369 2370func validateOpDeleteTagsInput(v *DeleteTagsInput) error { 2371 if v == nil { 2372 return nil 2373 } 2374 invalidParams := smithy.InvalidParamsError{Context: "DeleteTagsInput"} 2375 if v.ResourceName == nil { 2376 invalidParams.Add(smithy.NewErrParamRequired("ResourceName")) 2377 } 2378 if v.TagKeys == nil { 2379 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 2380 } 2381 if invalidParams.Len() > 0 { 2382 return invalidParams 2383 } else { 2384 return nil 2385 } 2386} 2387 2388func validateOpDeleteUsageLimitInput(v *DeleteUsageLimitInput) error { 2389 if v == nil { 2390 return nil 2391 } 2392 invalidParams := smithy.InvalidParamsError{Context: "DeleteUsageLimitInput"} 2393 if v.UsageLimitId == nil { 2394 invalidParams.Add(smithy.NewErrParamRequired("UsageLimitId")) 2395 } 2396 if invalidParams.Len() > 0 { 2397 return invalidParams 2398 } else { 2399 return nil 2400 } 2401} 2402 2403func validateOpDescribeClusterParametersInput(v *DescribeClusterParametersInput) error { 2404 if v == nil { 2405 return nil 2406 } 2407 invalidParams := smithy.InvalidParamsError{Context: "DescribeClusterParametersInput"} 2408 if v.ParameterGroupName == nil { 2409 invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName")) 2410 } 2411 if invalidParams.Len() > 0 { 2412 return invalidParams 2413 } else { 2414 return nil 2415 } 2416} 2417 2418func validateOpDescribeClusterSnapshotsInput(v *DescribeClusterSnapshotsInput) error { 2419 if v == nil { 2420 return nil 2421 } 2422 invalidParams := smithy.InvalidParamsError{Context: "DescribeClusterSnapshotsInput"} 2423 if v.SortingEntities != nil { 2424 if err := validateSnapshotSortingEntityList(v.SortingEntities); err != nil { 2425 invalidParams.AddNested("SortingEntities", err.(smithy.InvalidParamsError)) 2426 } 2427 } 2428 if invalidParams.Len() > 0 { 2429 return invalidParams 2430 } else { 2431 return nil 2432 } 2433} 2434 2435func validateOpDescribeDefaultClusterParametersInput(v *DescribeDefaultClusterParametersInput) error { 2436 if v == nil { 2437 return nil 2438 } 2439 invalidParams := smithy.InvalidParamsError{Context: "DescribeDefaultClusterParametersInput"} 2440 if v.ParameterGroupFamily == nil { 2441 invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupFamily")) 2442 } 2443 if invalidParams.Len() > 0 { 2444 return invalidParams 2445 } else { 2446 return nil 2447 } 2448} 2449 2450func validateOpDescribeLoggingStatusInput(v *DescribeLoggingStatusInput) error { 2451 if v == nil { 2452 return nil 2453 } 2454 invalidParams := smithy.InvalidParamsError{Context: "DescribeLoggingStatusInput"} 2455 if v.ClusterIdentifier == nil { 2456 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2457 } 2458 if invalidParams.Len() > 0 { 2459 return invalidParams 2460 } else { 2461 return nil 2462 } 2463} 2464 2465func validateOpDescribeNodeConfigurationOptionsInput(v *DescribeNodeConfigurationOptionsInput) error { 2466 if v == nil { 2467 return nil 2468 } 2469 invalidParams := smithy.InvalidParamsError{Context: "DescribeNodeConfigurationOptionsInput"} 2470 if len(v.ActionType) == 0 { 2471 invalidParams.Add(smithy.NewErrParamRequired("ActionType")) 2472 } 2473 if invalidParams.Len() > 0 { 2474 return invalidParams 2475 } else { 2476 return nil 2477 } 2478} 2479 2480func validateOpDescribeResizeInput(v *DescribeResizeInput) error { 2481 if v == nil { 2482 return nil 2483 } 2484 invalidParams := smithy.InvalidParamsError{Context: "DescribeResizeInput"} 2485 if v.ClusterIdentifier == nil { 2486 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2487 } 2488 if invalidParams.Len() > 0 { 2489 return invalidParams 2490 } else { 2491 return nil 2492 } 2493} 2494 2495func validateOpDescribeScheduledActionsInput(v *DescribeScheduledActionsInput) error { 2496 if v == nil { 2497 return nil 2498 } 2499 invalidParams := smithy.InvalidParamsError{Context: "DescribeScheduledActionsInput"} 2500 if v.Filters != nil { 2501 if err := validateScheduledActionFilterList(v.Filters); err != nil { 2502 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 2503 } 2504 } 2505 if invalidParams.Len() > 0 { 2506 return invalidParams 2507 } else { 2508 return nil 2509 } 2510} 2511 2512func validateOpDisableLoggingInput(v *DisableLoggingInput) error { 2513 if v == nil { 2514 return nil 2515 } 2516 invalidParams := smithy.InvalidParamsError{Context: "DisableLoggingInput"} 2517 if v.ClusterIdentifier == nil { 2518 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2519 } 2520 if invalidParams.Len() > 0 { 2521 return invalidParams 2522 } else { 2523 return nil 2524 } 2525} 2526 2527func validateOpDisableSnapshotCopyInput(v *DisableSnapshotCopyInput) error { 2528 if v == nil { 2529 return nil 2530 } 2531 invalidParams := smithy.InvalidParamsError{Context: "DisableSnapshotCopyInput"} 2532 if v.ClusterIdentifier == nil { 2533 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2534 } 2535 if invalidParams.Len() > 0 { 2536 return invalidParams 2537 } else { 2538 return nil 2539 } 2540} 2541 2542func validateOpEnableLoggingInput(v *EnableLoggingInput) error { 2543 if v == nil { 2544 return nil 2545 } 2546 invalidParams := smithy.InvalidParamsError{Context: "EnableLoggingInput"} 2547 if v.ClusterIdentifier == nil { 2548 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2549 } 2550 if v.BucketName == nil { 2551 invalidParams.Add(smithy.NewErrParamRequired("BucketName")) 2552 } 2553 if invalidParams.Len() > 0 { 2554 return invalidParams 2555 } else { 2556 return nil 2557 } 2558} 2559 2560func validateOpEnableSnapshotCopyInput(v *EnableSnapshotCopyInput) error { 2561 if v == nil { 2562 return nil 2563 } 2564 invalidParams := smithy.InvalidParamsError{Context: "EnableSnapshotCopyInput"} 2565 if v.ClusterIdentifier == nil { 2566 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2567 } 2568 if v.DestinationRegion == nil { 2569 invalidParams.Add(smithy.NewErrParamRequired("DestinationRegion")) 2570 } 2571 if invalidParams.Len() > 0 { 2572 return invalidParams 2573 } else { 2574 return nil 2575 } 2576} 2577 2578func validateOpGetClusterCredentialsInput(v *GetClusterCredentialsInput) error { 2579 if v == nil { 2580 return nil 2581 } 2582 invalidParams := smithy.InvalidParamsError{Context: "GetClusterCredentialsInput"} 2583 if v.DbUser == nil { 2584 invalidParams.Add(smithy.NewErrParamRequired("DbUser")) 2585 } 2586 if v.ClusterIdentifier == nil { 2587 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2588 } 2589 if invalidParams.Len() > 0 { 2590 return invalidParams 2591 } else { 2592 return nil 2593 } 2594} 2595 2596func validateOpGetReservedNodeExchangeOfferingsInput(v *GetReservedNodeExchangeOfferingsInput) error { 2597 if v == nil { 2598 return nil 2599 } 2600 invalidParams := smithy.InvalidParamsError{Context: "GetReservedNodeExchangeOfferingsInput"} 2601 if v.ReservedNodeId == nil { 2602 invalidParams.Add(smithy.NewErrParamRequired("ReservedNodeId")) 2603 } 2604 if invalidParams.Len() > 0 { 2605 return invalidParams 2606 } else { 2607 return nil 2608 } 2609} 2610 2611func validateOpModifyClusterDbRevisionInput(v *ModifyClusterDbRevisionInput) error { 2612 if v == nil { 2613 return nil 2614 } 2615 invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterDbRevisionInput"} 2616 if v.ClusterIdentifier == nil { 2617 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2618 } 2619 if v.RevisionTarget == nil { 2620 invalidParams.Add(smithy.NewErrParamRequired("RevisionTarget")) 2621 } 2622 if invalidParams.Len() > 0 { 2623 return invalidParams 2624 } else { 2625 return nil 2626 } 2627} 2628 2629func validateOpModifyClusterIamRolesInput(v *ModifyClusterIamRolesInput) error { 2630 if v == nil { 2631 return nil 2632 } 2633 invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterIamRolesInput"} 2634 if v.ClusterIdentifier == nil { 2635 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2636 } 2637 if invalidParams.Len() > 0 { 2638 return invalidParams 2639 } else { 2640 return nil 2641 } 2642} 2643 2644func validateOpModifyClusterInput(v *ModifyClusterInput) error { 2645 if v == nil { 2646 return nil 2647 } 2648 invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterInput"} 2649 if v.ClusterIdentifier == nil { 2650 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2651 } 2652 if invalidParams.Len() > 0 { 2653 return invalidParams 2654 } else { 2655 return nil 2656 } 2657} 2658 2659func validateOpModifyClusterMaintenanceInput(v *ModifyClusterMaintenanceInput) error { 2660 if v == nil { 2661 return nil 2662 } 2663 invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterMaintenanceInput"} 2664 if v.ClusterIdentifier == nil { 2665 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2666 } 2667 if invalidParams.Len() > 0 { 2668 return invalidParams 2669 } else { 2670 return nil 2671 } 2672} 2673 2674func validateOpModifyClusterParameterGroupInput(v *ModifyClusterParameterGroupInput) error { 2675 if v == nil { 2676 return nil 2677 } 2678 invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterParameterGroupInput"} 2679 if v.ParameterGroupName == nil { 2680 invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName")) 2681 } 2682 if v.Parameters == nil { 2683 invalidParams.Add(smithy.NewErrParamRequired("Parameters")) 2684 } 2685 if invalidParams.Len() > 0 { 2686 return invalidParams 2687 } else { 2688 return nil 2689 } 2690} 2691 2692func validateOpModifyClusterSnapshotInput(v *ModifyClusterSnapshotInput) error { 2693 if v == nil { 2694 return nil 2695 } 2696 invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterSnapshotInput"} 2697 if v.SnapshotIdentifier == nil { 2698 invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier")) 2699 } 2700 if invalidParams.Len() > 0 { 2701 return invalidParams 2702 } else { 2703 return nil 2704 } 2705} 2706 2707func validateOpModifyClusterSnapshotScheduleInput(v *ModifyClusterSnapshotScheduleInput) error { 2708 if v == nil { 2709 return nil 2710 } 2711 invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterSnapshotScheduleInput"} 2712 if v.ClusterIdentifier == nil { 2713 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2714 } 2715 if invalidParams.Len() > 0 { 2716 return invalidParams 2717 } else { 2718 return nil 2719 } 2720} 2721 2722func validateOpModifyClusterSubnetGroupInput(v *ModifyClusterSubnetGroupInput) error { 2723 if v == nil { 2724 return nil 2725 } 2726 invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterSubnetGroupInput"} 2727 if v.ClusterSubnetGroupName == nil { 2728 invalidParams.Add(smithy.NewErrParamRequired("ClusterSubnetGroupName")) 2729 } 2730 if v.SubnetIds == nil { 2731 invalidParams.Add(smithy.NewErrParamRequired("SubnetIds")) 2732 } 2733 if invalidParams.Len() > 0 { 2734 return invalidParams 2735 } else { 2736 return nil 2737 } 2738} 2739 2740func validateOpModifyEventSubscriptionInput(v *ModifyEventSubscriptionInput) error { 2741 if v == nil { 2742 return nil 2743 } 2744 invalidParams := smithy.InvalidParamsError{Context: "ModifyEventSubscriptionInput"} 2745 if v.SubscriptionName == nil { 2746 invalidParams.Add(smithy.NewErrParamRequired("SubscriptionName")) 2747 } 2748 if invalidParams.Len() > 0 { 2749 return invalidParams 2750 } else { 2751 return nil 2752 } 2753} 2754 2755func validateOpModifyScheduledActionInput(v *ModifyScheduledActionInput) error { 2756 if v == nil { 2757 return nil 2758 } 2759 invalidParams := smithy.InvalidParamsError{Context: "ModifyScheduledActionInput"} 2760 if v.ScheduledActionName == nil { 2761 invalidParams.Add(smithy.NewErrParamRequired("ScheduledActionName")) 2762 } 2763 if v.TargetAction != nil { 2764 if err := validateScheduledActionType(v.TargetAction); err != nil { 2765 invalidParams.AddNested("TargetAction", err.(smithy.InvalidParamsError)) 2766 } 2767 } 2768 if invalidParams.Len() > 0 { 2769 return invalidParams 2770 } else { 2771 return nil 2772 } 2773} 2774 2775func validateOpModifySnapshotCopyRetentionPeriodInput(v *ModifySnapshotCopyRetentionPeriodInput) error { 2776 if v == nil { 2777 return nil 2778 } 2779 invalidParams := smithy.InvalidParamsError{Context: "ModifySnapshotCopyRetentionPeriodInput"} 2780 if v.ClusterIdentifier == nil { 2781 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2782 } 2783 if invalidParams.Len() > 0 { 2784 return invalidParams 2785 } else { 2786 return nil 2787 } 2788} 2789 2790func validateOpModifySnapshotScheduleInput(v *ModifySnapshotScheduleInput) error { 2791 if v == nil { 2792 return nil 2793 } 2794 invalidParams := smithy.InvalidParamsError{Context: "ModifySnapshotScheduleInput"} 2795 if v.ScheduleIdentifier == nil { 2796 invalidParams.Add(smithy.NewErrParamRequired("ScheduleIdentifier")) 2797 } 2798 if v.ScheduleDefinitions == nil { 2799 invalidParams.Add(smithy.NewErrParamRequired("ScheduleDefinitions")) 2800 } 2801 if invalidParams.Len() > 0 { 2802 return invalidParams 2803 } else { 2804 return nil 2805 } 2806} 2807 2808func validateOpModifyUsageLimitInput(v *ModifyUsageLimitInput) error { 2809 if v == nil { 2810 return nil 2811 } 2812 invalidParams := smithy.InvalidParamsError{Context: "ModifyUsageLimitInput"} 2813 if v.UsageLimitId == nil { 2814 invalidParams.Add(smithy.NewErrParamRequired("UsageLimitId")) 2815 } 2816 if invalidParams.Len() > 0 { 2817 return invalidParams 2818 } else { 2819 return nil 2820 } 2821} 2822 2823func validateOpPauseClusterInput(v *PauseClusterInput) error { 2824 if v == nil { 2825 return nil 2826 } 2827 invalidParams := smithy.InvalidParamsError{Context: "PauseClusterInput"} 2828 if v.ClusterIdentifier == nil { 2829 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2830 } 2831 if invalidParams.Len() > 0 { 2832 return invalidParams 2833 } else { 2834 return nil 2835 } 2836} 2837 2838func validateOpPurchaseReservedNodeOfferingInput(v *PurchaseReservedNodeOfferingInput) error { 2839 if v == nil { 2840 return nil 2841 } 2842 invalidParams := smithy.InvalidParamsError{Context: "PurchaseReservedNodeOfferingInput"} 2843 if v.ReservedNodeOfferingId == nil { 2844 invalidParams.Add(smithy.NewErrParamRequired("ReservedNodeOfferingId")) 2845 } 2846 if invalidParams.Len() > 0 { 2847 return invalidParams 2848 } else { 2849 return nil 2850 } 2851} 2852 2853func validateOpRebootClusterInput(v *RebootClusterInput) error { 2854 if v == nil { 2855 return nil 2856 } 2857 invalidParams := smithy.InvalidParamsError{Context: "RebootClusterInput"} 2858 if v.ClusterIdentifier == nil { 2859 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2860 } 2861 if invalidParams.Len() > 0 { 2862 return invalidParams 2863 } else { 2864 return nil 2865 } 2866} 2867 2868func validateOpResetClusterParameterGroupInput(v *ResetClusterParameterGroupInput) error { 2869 if v == nil { 2870 return nil 2871 } 2872 invalidParams := smithy.InvalidParamsError{Context: "ResetClusterParameterGroupInput"} 2873 if v.ParameterGroupName == nil { 2874 invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName")) 2875 } 2876 if invalidParams.Len() > 0 { 2877 return invalidParams 2878 } else { 2879 return nil 2880 } 2881} 2882 2883func validateOpResizeClusterInput(v *ResizeClusterInput) error { 2884 if v == nil { 2885 return nil 2886 } 2887 invalidParams := smithy.InvalidParamsError{Context: "ResizeClusterInput"} 2888 if v.ClusterIdentifier == nil { 2889 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2890 } 2891 if invalidParams.Len() > 0 { 2892 return invalidParams 2893 } else { 2894 return nil 2895 } 2896} 2897 2898func validateOpRestoreFromClusterSnapshotInput(v *RestoreFromClusterSnapshotInput) error { 2899 if v == nil { 2900 return nil 2901 } 2902 invalidParams := smithy.InvalidParamsError{Context: "RestoreFromClusterSnapshotInput"} 2903 if v.ClusterIdentifier == nil { 2904 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2905 } 2906 if v.SnapshotIdentifier == nil { 2907 invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier")) 2908 } 2909 if invalidParams.Len() > 0 { 2910 return invalidParams 2911 } else { 2912 return nil 2913 } 2914} 2915 2916func validateOpRestoreTableFromClusterSnapshotInput(v *RestoreTableFromClusterSnapshotInput) error { 2917 if v == nil { 2918 return nil 2919 } 2920 invalidParams := smithy.InvalidParamsError{Context: "RestoreTableFromClusterSnapshotInput"} 2921 if v.ClusterIdentifier == nil { 2922 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2923 } 2924 if v.SnapshotIdentifier == nil { 2925 invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier")) 2926 } 2927 if v.SourceDatabaseName == nil { 2928 invalidParams.Add(smithy.NewErrParamRequired("SourceDatabaseName")) 2929 } 2930 if v.SourceTableName == nil { 2931 invalidParams.Add(smithy.NewErrParamRequired("SourceTableName")) 2932 } 2933 if v.NewTableName == nil { 2934 invalidParams.Add(smithy.NewErrParamRequired("NewTableName")) 2935 } 2936 if invalidParams.Len() > 0 { 2937 return invalidParams 2938 } else { 2939 return nil 2940 } 2941} 2942 2943func validateOpResumeClusterInput(v *ResumeClusterInput) error { 2944 if v == nil { 2945 return nil 2946 } 2947 invalidParams := smithy.InvalidParamsError{Context: "ResumeClusterInput"} 2948 if v.ClusterIdentifier == nil { 2949 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2950 } 2951 if invalidParams.Len() > 0 { 2952 return invalidParams 2953 } else { 2954 return nil 2955 } 2956} 2957 2958func validateOpRevokeClusterSecurityGroupIngressInput(v *RevokeClusterSecurityGroupIngressInput) error { 2959 if v == nil { 2960 return nil 2961 } 2962 invalidParams := smithy.InvalidParamsError{Context: "RevokeClusterSecurityGroupIngressInput"} 2963 if v.ClusterSecurityGroupName == nil { 2964 invalidParams.Add(smithy.NewErrParamRequired("ClusterSecurityGroupName")) 2965 } 2966 if invalidParams.Len() > 0 { 2967 return invalidParams 2968 } else { 2969 return nil 2970 } 2971} 2972 2973func validateOpRevokeSnapshotAccessInput(v *RevokeSnapshotAccessInput) error { 2974 if v == nil { 2975 return nil 2976 } 2977 invalidParams := smithy.InvalidParamsError{Context: "RevokeSnapshotAccessInput"} 2978 if v.SnapshotIdentifier == nil { 2979 invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier")) 2980 } 2981 if v.AccountWithRestoreAccess == nil { 2982 invalidParams.Add(smithy.NewErrParamRequired("AccountWithRestoreAccess")) 2983 } 2984 if invalidParams.Len() > 0 { 2985 return invalidParams 2986 } else { 2987 return nil 2988 } 2989} 2990 2991func validateOpRotateEncryptionKeyInput(v *RotateEncryptionKeyInput) error { 2992 if v == nil { 2993 return nil 2994 } 2995 invalidParams := smithy.InvalidParamsError{Context: "RotateEncryptionKeyInput"} 2996 if v.ClusterIdentifier == nil { 2997 invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier")) 2998 } 2999 if invalidParams.Len() > 0 { 3000 return invalidParams 3001 } else { 3002 return nil 3003 } 3004} 3005