1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package opsworks 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/opsworks/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpAssignInstance struct { 14} 15 16func (*validateOpAssignInstance) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpAssignInstance) 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.(*AssignInstanceInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpAssignInstanceInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpAssignVolume struct { 34} 35 36func (*validateOpAssignVolume) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpAssignVolume) 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.(*AssignVolumeInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpAssignVolumeInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpAssociateElasticIp struct { 54} 55 56func (*validateOpAssociateElasticIp) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpAssociateElasticIp) 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.(*AssociateElasticIpInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpAssociateElasticIpInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpAttachElasticLoadBalancer struct { 74} 75 76func (*validateOpAttachElasticLoadBalancer) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpAttachElasticLoadBalancer) 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.(*AttachElasticLoadBalancerInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpAttachElasticLoadBalancerInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCloneStack struct { 94} 95 96func (*validateOpCloneStack) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCloneStack) 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.(*CloneStackInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCloneStackInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateApp struct { 114} 115 116func (*validateOpCreateApp) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateApp) 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.(*CreateAppInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateAppInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpCreateDeployment struct { 134} 135 136func (*validateOpCreateDeployment) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpCreateDeployment) 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.(*CreateDeploymentInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpCreateDeploymentInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpCreateInstance struct { 154} 155 156func (*validateOpCreateInstance) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpCreateInstance) 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.(*CreateInstanceInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpCreateInstanceInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpCreateLayer struct { 174} 175 176func (*validateOpCreateLayer) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpCreateLayer) 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.(*CreateLayerInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpCreateLayerInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpCreateStack struct { 194} 195 196func (*validateOpCreateStack) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpCreateStack) 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.(*CreateStackInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpCreateStackInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpCreateUserProfile struct { 214} 215 216func (*validateOpCreateUserProfile) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpCreateUserProfile) 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.(*CreateUserProfileInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpCreateUserProfileInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDeleteApp struct { 234} 235 236func (*validateOpDeleteApp) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDeleteApp) 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.(*DeleteAppInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDeleteAppInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDeleteInstance struct { 254} 255 256func (*validateOpDeleteInstance) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDeleteInstance) 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.(*DeleteInstanceInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDeleteInstanceInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDeleteLayer struct { 274} 275 276func (*validateOpDeleteLayer) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDeleteLayer) 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.(*DeleteLayerInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDeleteLayerInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpDeleteStack struct { 294} 295 296func (*validateOpDeleteStack) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpDeleteStack) 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.(*DeleteStackInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpDeleteStackInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpDeleteUserProfile struct { 314} 315 316func (*validateOpDeleteUserProfile) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpDeleteUserProfile) 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.(*DeleteUserProfileInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpDeleteUserProfileInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpDeregisterEcsCluster struct { 334} 335 336func (*validateOpDeregisterEcsCluster) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpDeregisterEcsCluster) 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.(*DeregisterEcsClusterInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpDeregisterEcsClusterInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpDeregisterElasticIp struct { 354} 355 356func (*validateOpDeregisterElasticIp) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpDeregisterElasticIp) 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.(*DeregisterElasticIpInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpDeregisterElasticIpInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpDeregisterInstance struct { 374} 375 376func (*validateOpDeregisterInstance) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpDeregisterInstance) 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.(*DeregisterInstanceInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpDeregisterInstanceInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpDeregisterRdsDbInstance struct { 394} 395 396func (*validateOpDeregisterRdsDbInstance) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpDeregisterRdsDbInstance) 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.(*DeregisterRdsDbInstanceInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpDeregisterRdsDbInstanceInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpDeregisterVolume struct { 414} 415 416func (*validateOpDeregisterVolume) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpDeregisterVolume) 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.(*DeregisterVolumeInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpDeregisterVolumeInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpDescribeLoadBasedAutoScaling struct { 434} 435 436func (*validateOpDescribeLoadBasedAutoScaling) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpDescribeLoadBasedAutoScaling) 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.(*DescribeLoadBasedAutoScalingInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpDescribeLoadBasedAutoScalingInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpDescribeRdsDbInstances struct { 454} 455 456func (*validateOpDescribeRdsDbInstances) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpDescribeRdsDbInstances) 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.(*DescribeRdsDbInstancesInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpDescribeRdsDbInstancesInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpDescribeStackProvisioningParameters struct { 474} 475 476func (*validateOpDescribeStackProvisioningParameters) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpDescribeStackProvisioningParameters) 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.(*DescribeStackProvisioningParametersInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpDescribeStackProvisioningParametersInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpDescribeStackSummary struct { 494} 495 496func (*validateOpDescribeStackSummary) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpDescribeStackSummary) 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.(*DescribeStackSummaryInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpDescribeStackSummaryInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpDescribeTimeBasedAutoScaling struct { 514} 515 516func (*validateOpDescribeTimeBasedAutoScaling) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpDescribeTimeBasedAutoScaling) 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.(*DescribeTimeBasedAutoScalingInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpDescribeTimeBasedAutoScalingInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpDetachElasticLoadBalancer struct { 534} 535 536func (*validateOpDetachElasticLoadBalancer) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpDetachElasticLoadBalancer) 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.(*DetachElasticLoadBalancerInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpDetachElasticLoadBalancerInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpDisassociateElasticIp struct { 554} 555 556func (*validateOpDisassociateElasticIp) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpDisassociateElasticIp) 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.(*DisassociateElasticIpInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpDisassociateElasticIpInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpGetHostnameSuggestion struct { 574} 575 576func (*validateOpGetHostnameSuggestion) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpGetHostnameSuggestion) 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.(*GetHostnameSuggestionInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpGetHostnameSuggestionInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpGrantAccess struct { 594} 595 596func (*validateOpGrantAccess) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpGrantAccess) 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.(*GrantAccessInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpGrantAccessInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpListTags struct { 614} 615 616func (*validateOpListTags) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpListTags) 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.(*ListTagsInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpListTagsInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpRebootInstance struct { 634} 635 636func (*validateOpRebootInstance) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpRebootInstance) 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.(*RebootInstanceInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpRebootInstanceInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpRegisterEcsCluster struct { 654} 655 656func (*validateOpRegisterEcsCluster) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpRegisterEcsCluster) 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.(*RegisterEcsClusterInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpRegisterEcsClusterInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpRegisterElasticIp struct { 674} 675 676func (*validateOpRegisterElasticIp) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpRegisterElasticIp) 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.(*RegisterElasticIpInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpRegisterElasticIpInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpRegisterInstance struct { 694} 695 696func (*validateOpRegisterInstance) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpRegisterInstance) 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.(*RegisterInstanceInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpRegisterInstanceInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpRegisterRdsDbInstance struct { 714} 715 716func (*validateOpRegisterRdsDbInstance) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpRegisterRdsDbInstance) 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.(*RegisterRdsDbInstanceInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpRegisterRdsDbInstanceInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpRegisterVolume struct { 734} 735 736func (*validateOpRegisterVolume) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpRegisterVolume) 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.(*RegisterVolumeInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpRegisterVolumeInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753type validateOpSetLoadBasedAutoScaling struct { 754} 755 756func (*validateOpSetLoadBasedAutoScaling) ID() string { 757 return "OperationInputValidation" 758} 759 760func (m *validateOpSetLoadBasedAutoScaling) 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.(*SetLoadBasedAutoScalingInput) 764 if !ok { 765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 766 } 767 if err := validateOpSetLoadBasedAutoScalingInput(input); err != nil { 768 return out, metadata, err 769 } 770 return next.HandleInitialize(ctx, in) 771} 772 773type validateOpSetPermission struct { 774} 775 776func (*validateOpSetPermission) ID() string { 777 return "OperationInputValidation" 778} 779 780func (m *validateOpSetPermission) 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.(*SetPermissionInput) 784 if !ok { 785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 786 } 787 if err := validateOpSetPermissionInput(input); err != nil { 788 return out, metadata, err 789 } 790 return next.HandleInitialize(ctx, in) 791} 792 793type validateOpSetTimeBasedAutoScaling struct { 794} 795 796func (*validateOpSetTimeBasedAutoScaling) ID() string { 797 return "OperationInputValidation" 798} 799 800func (m *validateOpSetTimeBasedAutoScaling) 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.(*SetTimeBasedAutoScalingInput) 804 if !ok { 805 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 806 } 807 if err := validateOpSetTimeBasedAutoScalingInput(input); err != nil { 808 return out, metadata, err 809 } 810 return next.HandleInitialize(ctx, in) 811} 812 813type validateOpStartInstance struct { 814} 815 816func (*validateOpStartInstance) ID() string { 817 return "OperationInputValidation" 818} 819 820func (m *validateOpStartInstance) 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.(*StartInstanceInput) 824 if !ok { 825 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 826 } 827 if err := validateOpStartInstanceInput(input); err != nil { 828 return out, metadata, err 829 } 830 return next.HandleInitialize(ctx, in) 831} 832 833type validateOpStartStack struct { 834} 835 836func (*validateOpStartStack) ID() string { 837 return "OperationInputValidation" 838} 839 840func (m *validateOpStartStack) 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.(*StartStackInput) 844 if !ok { 845 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 846 } 847 if err := validateOpStartStackInput(input); err != nil { 848 return out, metadata, err 849 } 850 return next.HandleInitialize(ctx, in) 851} 852 853type validateOpStopInstance struct { 854} 855 856func (*validateOpStopInstance) ID() string { 857 return "OperationInputValidation" 858} 859 860func (m *validateOpStopInstance) 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.(*StopInstanceInput) 864 if !ok { 865 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 866 } 867 if err := validateOpStopInstanceInput(input); err != nil { 868 return out, metadata, err 869 } 870 return next.HandleInitialize(ctx, in) 871} 872 873type validateOpStopStack struct { 874} 875 876func (*validateOpStopStack) ID() string { 877 return "OperationInputValidation" 878} 879 880func (m *validateOpStopStack) 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.(*StopStackInput) 884 if !ok { 885 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 886 } 887 if err := validateOpStopStackInput(input); err != nil { 888 return out, metadata, err 889 } 890 return next.HandleInitialize(ctx, in) 891} 892 893type validateOpTagResource struct { 894} 895 896func (*validateOpTagResource) ID() string { 897 return "OperationInputValidation" 898} 899 900func (m *validateOpTagResource) 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.(*TagResourceInput) 904 if !ok { 905 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 906 } 907 if err := validateOpTagResourceInput(input); err != nil { 908 return out, metadata, err 909 } 910 return next.HandleInitialize(ctx, in) 911} 912 913type validateOpUnassignInstance struct { 914} 915 916func (*validateOpUnassignInstance) ID() string { 917 return "OperationInputValidation" 918} 919 920func (m *validateOpUnassignInstance) 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.(*UnassignInstanceInput) 924 if !ok { 925 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 926 } 927 if err := validateOpUnassignInstanceInput(input); err != nil { 928 return out, metadata, err 929 } 930 return next.HandleInitialize(ctx, in) 931} 932 933type validateOpUnassignVolume struct { 934} 935 936func (*validateOpUnassignVolume) ID() string { 937 return "OperationInputValidation" 938} 939 940func (m *validateOpUnassignVolume) 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.(*UnassignVolumeInput) 944 if !ok { 945 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 946 } 947 if err := validateOpUnassignVolumeInput(input); err != nil { 948 return out, metadata, err 949 } 950 return next.HandleInitialize(ctx, in) 951} 952 953type validateOpUntagResource struct { 954} 955 956func (*validateOpUntagResource) ID() string { 957 return "OperationInputValidation" 958} 959 960func (m *validateOpUntagResource) 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.(*UntagResourceInput) 964 if !ok { 965 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 966 } 967 if err := validateOpUntagResourceInput(input); err != nil { 968 return out, metadata, err 969 } 970 return next.HandleInitialize(ctx, in) 971} 972 973type validateOpUpdateApp struct { 974} 975 976func (*validateOpUpdateApp) ID() string { 977 return "OperationInputValidation" 978} 979 980func (m *validateOpUpdateApp) 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.(*UpdateAppInput) 984 if !ok { 985 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 986 } 987 if err := validateOpUpdateAppInput(input); err != nil { 988 return out, metadata, err 989 } 990 return next.HandleInitialize(ctx, in) 991} 992 993type validateOpUpdateElasticIp struct { 994} 995 996func (*validateOpUpdateElasticIp) ID() string { 997 return "OperationInputValidation" 998} 999 1000func (m *validateOpUpdateElasticIp) 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.(*UpdateElasticIpInput) 1004 if !ok { 1005 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1006 } 1007 if err := validateOpUpdateElasticIpInput(input); err != nil { 1008 return out, metadata, err 1009 } 1010 return next.HandleInitialize(ctx, in) 1011} 1012 1013type validateOpUpdateInstance struct { 1014} 1015 1016func (*validateOpUpdateInstance) ID() string { 1017 return "OperationInputValidation" 1018} 1019 1020func (m *validateOpUpdateInstance) 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.(*UpdateInstanceInput) 1024 if !ok { 1025 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1026 } 1027 if err := validateOpUpdateInstanceInput(input); err != nil { 1028 return out, metadata, err 1029 } 1030 return next.HandleInitialize(ctx, in) 1031} 1032 1033type validateOpUpdateLayer struct { 1034} 1035 1036func (*validateOpUpdateLayer) ID() string { 1037 return "OperationInputValidation" 1038} 1039 1040func (m *validateOpUpdateLayer) 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.(*UpdateLayerInput) 1044 if !ok { 1045 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1046 } 1047 if err := validateOpUpdateLayerInput(input); err != nil { 1048 return out, metadata, err 1049 } 1050 return next.HandleInitialize(ctx, in) 1051} 1052 1053type validateOpUpdateRdsDbInstance struct { 1054} 1055 1056func (*validateOpUpdateRdsDbInstance) ID() string { 1057 return "OperationInputValidation" 1058} 1059 1060func (m *validateOpUpdateRdsDbInstance) 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.(*UpdateRdsDbInstanceInput) 1064 if !ok { 1065 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1066 } 1067 if err := validateOpUpdateRdsDbInstanceInput(input); err != nil { 1068 return out, metadata, err 1069 } 1070 return next.HandleInitialize(ctx, in) 1071} 1072 1073type validateOpUpdateStack struct { 1074} 1075 1076func (*validateOpUpdateStack) ID() string { 1077 return "OperationInputValidation" 1078} 1079 1080func (m *validateOpUpdateStack) 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.(*UpdateStackInput) 1084 if !ok { 1085 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1086 } 1087 if err := validateOpUpdateStackInput(input); err != nil { 1088 return out, metadata, err 1089 } 1090 return next.HandleInitialize(ctx, in) 1091} 1092 1093type validateOpUpdateUserProfile struct { 1094} 1095 1096func (*validateOpUpdateUserProfile) ID() string { 1097 return "OperationInputValidation" 1098} 1099 1100func (m *validateOpUpdateUserProfile) 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.(*UpdateUserProfileInput) 1104 if !ok { 1105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1106 } 1107 if err := validateOpUpdateUserProfileInput(input); err != nil { 1108 return out, metadata, err 1109 } 1110 return next.HandleInitialize(ctx, in) 1111} 1112 1113type validateOpUpdateVolume struct { 1114} 1115 1116func (*validateOpUpdateVolume) ID() string { 1117 return "OperationInputValidation" 1118} 1119 1120func (m *validateOpUpdateVolume) 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.(*UpdateVolumeInput) 1124 if !ok { 1125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1126 } 1127 if err := validateOpUpdateVolumeInput(input); err != nil { 1128 return out, metadata, err 1129 } 1130 return next.HandleInitialize(ctx, in) 1131} 1132 1133func addOpAssignInstanceValidationMiddleware(stack *middleware.Stack) error { 1134 return stack.Initialize.Add(&validateOpAssignInstance{}, middleware.After) 1135} 1136 1137func addOpAssignVolumeValidationMiddleware(stack *middleware.Stack) error { 1138 return stack.Initialize.Add(&validateOpAssignVolume{}, middleware.After) 1139} 1140 1141func addOpAssociateElasticIpValidationMiddleware(stack *middleware.Stack) error { 1142 return stack.Initialize.Add(&validateOpAssociateElasticIp{}, middleware.After) 1143} 1144 1145func addOpAttachElasticLoadBalancerValidationMiddleware(stack *middleware.Stack) error { 1146 return stack.Initialize.Add(&validateOpAttachElasticLoadBalancer{}, middleware.After) 1147} 1148 1149func addOpCloneStackValidationMiddleware(stack *middleware.Stack) error { 1150 return stack.Initialize.Add(&validateOpCloneStack{}, middleware.After) 1151} 1152 1153func addOpCreateAppValidationMiddleware(stack *middleware.Stack) error { 1154 return stack.Initialize.Add(&validateOpCreateApp{}, middleware.After) 1155} 1156 1157func addOpCreateDeploymentValidationMiddleware(stack *middleware.Stack) error { 1158 return stack.Initialize.Add(&validateOpCreateDeployment{}, middleware.After) 1159} 1160 1161func addOpCreateInstanceValidationMiddleware(stack *middleware.Stack) error { 1162 return stack.Initialize.Add(&validateOpCreateInstance{}, middleware.After) 1163} 1164 1165func addOpCreateLayerValidationMiddleware(stack *middleware.Stack) error { 1166 return stack.Initialize.Add(&validateOpCreateLayer{}, middleware.After) 1167} 1168 1169func addOpCreateStackValidationMiddleware(stack *middleware.Stack) error { 1170 return stack.Initialize.Add(&validateOpCreateStack{}, middleware.After) 1171} 1172 1173func addOpCreateUserProfileValidationMiddleware(stack *middleware.Stack) error { 1174 return stack.Initialize.Add(&validateOpCreateUserProfile{}, middleware.After) 1175} 1176 1177func addOpDeleteAppValidationMiddleware(stack *middleware.Stack) error { 1178 return stack.Initialize.Add(&validateOpDeleteApp{}, middleware.After) 1179} 1180 1181func addOpDeleteInstanceValidationMiddleware(stack *middleware.Stack) error { 1182 return stack.Initialize.Add(&validateOpDeleteInstance{}, middleware.After) 1183} 1184 1185func addOpDeleteLayerValidationMiddleware(stack *middleware.Stack) error { 1186 return stack.Initialize.Add(&validateOpDeleteLayer{}, middleware.After) 1187} 1188 1189func addOpDeleteStackValidationMiddleware(stack *middleware.Stack) error { 1190 return stack.Initialize.Add(&validateOpDeleteStack{}, middleware.After) 1191} 1192 1193func addOpDeleteUserProfileValidationMiddleware(stack *middleware.Stack) error { 1194 return stack.Initialize.Add(&validateOpDeleteUserProfile{}, middleware.After) 1195} 1196 1197func addOpDeregisterEcsClusterValidationMiddleware(stack *middleware.Stack) error { 1198 return stack.Initialize.Add(&validateOpDeregisterEcsCluster{}, middleware.After) 1199} 1200 1201func addOpDeregisterElasticIpValidationMiddleware(stack *middleware.Stack) error { 1202 return stack.Initialize.Add(&validateOpDeregisterElasticIp{}, middleware.After) 1203} 1204 1205func addOpDeregisterInstanceValidationMiddleware(stack *middleware.Stack) error { 1206 return stack.Initialize.Add(&validateOpDeregisterInstance{}, middleware.After) 1207} 1208 1209func addOpDeregisterRdsDbInstanceValidationMiddleware(stack *middleware.Stack) error { 1210 return stack.Initialize.Add(&validateOpDeregisterRdsDbInstance{}, middleware.After) 1211} 1212 1213func addOpDeregisterVolumeValidationMiddleware(stack *middleware.Stack) error { 1214 return stack.Initialize.Add(&validateOpDeregisterVolume{}, middleware.After) 1215} 1216 1217func addOpDescribeLoadBasedAutoScalingValidationMiddleware(stack *middleware.Stack) error { 1218 return stack.Initialize.Add(&validateOpDescribeLoadBasedAutoScaling{}, middleware.After) 1219} 1220 1221func addOpDescribeRdsDbInstancesValidationMiddleware(stack *middleware.Stack) error { 1222 return stack.Initialize.Add(&validateOpDescribeRdsDbInstances{}, middleware.After) 1223} 1224 1225func addOpDescribeStackProvisioningParametersValidationMiddleware(stack *middleware.Stack) error { 1226 return stack.Initialize.Add(&validateOpDescribeStackProvisioningParameters{}, middleware.After) 1227} 1228 1229func addOpDescribeStackSummaryValidationMiddleware(stack *middleware.Stack) error { 1230 return stack.Initialize.Add(&validateOpDescribeStackSummary{}, middleware.After) 1231} 1232 1233func addOpDescribeTimeBasedAutoScalingValidationMiddleware(stack *middleware.Stack) error { 1234 return stack.Initialize.Add(&validateOpDescribeTimeBasedAutoScaling{}, middleware.After) 1235} 1236 1237func addOpDetachElasticLoadBalancerValidationMiddleware(stack *middleware.Stack) error { 1238 return stack.Initialize.Add(&validateOpDetachElasticLoadBalancer{}, middleware.After) 1239} 1240 1241func addOpDisassociateElasticIpValidationMiddleware(stack *middleware.Stack) error { 1242 return stack.Initialize.Add(&validateOpDisassociateElasticIp{}, middleware.After) 1243} 1244 1245func addOpGetHostnameSuggestionValidationMiddleware(stack *middleware.Stack) error { 1246 return stack.Initialize.Add(&validateOpGetHostnameSuggestion{}, middleware.After) 1247} 1248 1249func addOpGrantAccessValidationMiddleware(stack *middleware.Stack) error { 1250 return stack.Initialize.Add(&validateOpGrantAccess{}, middleware.After) 1251} 1252 1253func addOpListTagsValidationMiddleware(stack *middleware.Stack) error { 1254 return stack.Initialize.Add(&validateOpListTags{}, middleware.After) 1255} 1256 1257func addOpRebootInstanceValidationMiddleware(stack *middleware.Stack) error { 1258 return stack.Initialize.Add(&validateOpRebootInstance{}, middleware.After) 1259} 1260 1261func addOpRegisterEcsClusterValidationMiddleware(stack *middleware.Stack) error { 1262 return stack.Initialize.Add(&validateOpRegisterEcsCluster{}, middleware.After) 1263} 1264 1265func addOpRegisterElasticIpValidationMiddleware(stack *middleware.Stack) error { 1266 return stack.Initialize.Add(&validateOpRegisterElasticIp{}, middleware.After) 1267} 1268 1269func addOpRegisterInstanceValidationMiddleware(stack *middleware.Stack) error { 1270 return stack.Initialize.Add(&validateOpRegisterInstance{}, middleware.After) 1271} 1272 1273func addOpRegisterRdsDbInstanceValidationMiddleware(stack *middleware.Stack) error { 1274 return stack.Initialize.Add(&validateOpRegisterRdsDbInstance{}, middleware.After) 1275} 1276 1277func addOpRegisterVolumeValidationMiddleware(stack *middleware.Stack) error { 1278 return stack.Initialize.Add(&validateOpRegisterVolume{}, middleware.After) 1279} 1280 1281func addOpSetLoadBasedAutoScalingValidationMiddleware(stack *middleware.Stack) error { 1282 return stack.Initialize.Add(&validateOpSetLoadBasedAutoScaling{}, middleware.After) 1283} 1284 1285func addOpSetPermissionValidationMiddleware(stack *middleware.Stack) error { 1286 return stack.Initialize.Add(&validateOpSetPermission{}, middleware.After) 1287} 1288 1289func addOpSetTimeBasedAutoScalingValidationMiddleware(stack *middleware.Stack) error { 1290 return stack.Initialize.Add(&validateOpSetTimeBasedAutoScaling{}, middleware.After) 1291} 1292 1293func addOpStartInstanceValidationMiddleware(stack *middleware.Stack) error { 1294 return stack.Initialize.Add(&validateOpStartInstance{}, middleware.After) 1295} 1296 1297func addOpStartStackValidationMiddleware(stack *middleware.Stack) error { 1298 return stack.Initialize.Add(&validateOpStartStack{}, middleware.After) 1299} 1300 1301func addOpStopInstanceValidationMiddleware(stack *middleware.Stack) error { 1302 return stack.Initialize.Add(&validateOpStopInstance{}, middleware.After) 1303} 1304 1305func addOpStopStackValidationMiddleware(stack *middleware.Stack) error { 1306 return stack.Initialize.Add(&validateOpStopStack{}, middleware.After) 1307} 1308 1309func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 1310 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 1311} 1312 1313func addOpUnassignInstanceValidationMiddleware(stack *middleware.Stack) error { 1314 return stack.Initialize.Add(&validateOpUnassignInstance{}, middleware.After) 1315} 1316 1317func addOpUnassignVolumeValidationMiddleware(stack *middleware.Stack) error { 1318 return stack.Initialize.Add(&validateOpUnassignVolume{}, middleware.After) 1319} 1320 1321func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 1322 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 1323} 1324 1325func addOpUpdateAppValidationMiddleware(stack *middleware.Stack) error { 1326 return stack.Initialize.Add(&validateOpUpdateApp{}, middleware.After) 1327} 1328 1329func addOpUpdateElasticIpValidationMiddleware(stack *middleware.Stack) error { 1330 return stack.Initialize.Add(&validateOpUpdateElasticIp{}, middleware.After) 1331} 1332 1333func addOpUpdateInstanceValidationMiddleware(stack *middleware.Stack) error { 1334 return stack.Initialize.Add(&validateOpUpdateInstance{}, middleware.After) 1335} 1336 1337func addOpUpdateLayerValidationMiddleware(stack *middleware.Stack) error { 1338 return stack.Initialize.Add(&validateOpUpdateLayer{}, middleware.After) 1339} 1340 1341func addOpUpdateRdsDbInstanceValidationMiddleware(stack *middleware.Stack) error { 1342 return stack.Initialize.Add(&validateOpUpdateRdsDbInstance{}, middleware.After) 1343} 1344 1345func addOpUpdateStackValidationMiddleware(stack *middleware.Stack) error { 1346 return stack.Initialize.Add(&validateOpUpdateStack{}, middleware.After) 1347} 1348 1349func addOpUpdateUserProfileValidationMiddleware(stack *middleware.Stack) error { 1350 return stack.Initialize.Add(&validateOpUpdateUserProfile{}, middleware.After) 1351} 1352 1353func addOpUpdateVolumeValidationMiddleware(stack *middleware.Stack) error { 1354 return stack.Initialize.Add(&validateOpUpdateVolume{}, middleware.After) 1355} 1356 1357func validateDeploymentCommand(v *types.DeploymentCommand) error { 1358 if v == nil { 1359 return nil 1360 } 1361 invalidParams := smithy.InvalidParamsError{Context: "DeploymentCommand"} 1362 if len(v.Name) == 0 { 1363 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1364 } 1365 if invalidParams.Len() > 0 { 1366 return invalidParams 1367 } else { 1368 return nil 1369 } 1370} 1371 1372func validateEnvironmentVariable(v *types.EnvironmentVariable) error { 1373 if v == nil { 1374 return nil 1375 } 1376 invalidParams := smithy.InvalidParamsError{Context: "EnvironmentVariable"} 1377 if v.Key == nil { 1378 invalidParams.Add(smithy.NewErrParamRequired("Key")) 1379 } 1380 if v.Value == nil { 1381 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1382 } 1383 if invalidParams.Len() > 0 { 1384 return invalidParams 1385 } else { 1386 return nil 1387 } 1388} 1389 1390func validateEnvironmentVariables(v []types.EnvironmentVariable) error { 1391 if v == nil { 1392 return nil 1393 } 1394 invalidParams := smithy.InvalidParamsError{Context: "EnvironmentVariables"} 1395 for i := range v { 1396 if err := validateEnvironmentVariable(&v[i]); err != nil { 1397 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1398 } 1399 } 1400 if invalidParams.Len() > 0 { 1401 return invalidParams 1402 } else { 1403 return nil 1404 } 1405} 1406 1407func validateSslConfiguration(v *types.SslConfiguration) error { 1408 if v == nil { 1409 return nil 1410 } 1411 invalidParams := smithy.InvalidParamsError{Context: "SslConfiguration"} 1412 if v.Certificate == nil { 1413 invalidParams.Add(smithy.NewErrParamRequired("Certificate")) 1414 } 1415 if v.PrivateKey == nil { 1416 invalidParams.Add(smithy.NewErrParamRequired("PrivateKey")) 1417 } 1418 if invalidParams.Len() > 0 { 1419 return invalidParams 1420 } else { 1421 return nil 1422 } 1423} 1424 1425func validateVolumeConfiguration(v *types.VolumeConfiguration) error { 1426 if v == nil { 1427 return nil 1428 } 1429 invalidParams := smithy.InvalidParamsError{Context: "VolumeConfiguration"} 1430 if v.MountPoint == nil { 1431 invalidParams.Add(smithy.NewErrParamRequired("MountPoint")) 1432 } 1433 if v.NumberOfDisks == nil { 1434 invalidParams.Add(smithy.NewErrParamRequired("NumberOfDisks")) 1435 } 1436 if v.Size == nil { 1437 invalidParams.Add(smithy.NewErrParamRequired("Size")) 1438 } 1439 if invalidParams.Len() > 0 { 1440 return invalidParams 1441 } else { 1442 return nil 1443 } 1444} 1445 1446func validateVolumeConfigurations(v []types.VolumeConfiguration) error { 1447 if v == nil { 1448 return nil 1449 } 1450 invalidParams := smithy.InvalidParamsError{Context: "VolumeConfigurations"} 1451 for i := range v { 1452 if err := validateVolumeConfiguration(&v[i]); err != nil { 1453 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1454 } 1455 } 1456 if invalidParams.Len() > 0 { 1457 return invalidParams 1458 } else { 1459 return nil 1460 } 1461} 1462 1463func validateOpAssignInstanceInput(v *AssignInstanceInput) error { 1464 if v == nil { 1465 return nil 1466 } 1467 invalidParams := smithy.InvalidParamsError{Context: "AssignInstanceInput"} 1468 if v.InstanceId == nil { 1469 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 1470 } 1471 if v.LayerIds == nil { 1472 invalidParams.Add(smithy.NewErrParamRequired("LayerIds")) 1473 } 1474 if invalidParams.Len() > 0 { 1475 return invalidParams 1476 } else { 1477 return nil 1478 } 1479} 1480 1481func validateOpAssignVolumeInput(v *AssignVolumeInput) error { 1482 if v == nil { 1483 return nil 1484 } 1485 invalidParams := smithy.InvalidParamsError{Context: "AssignVolumeInput"} 1486 if v.VolumeId == nil { 1487 invalidParams.Add(smithy.NewErrParamRequired("VolumeId")) 1488 } 1489 if invalidParams.Len() > 0 { 1490 return invalidParams 1491 } else { 1492 return nil 1493 } 1494} 1495 1496func validateOpAssociateElasticIpInput(v *AssociateElasticIpInput) error { 1497 if v == nil { 1498 return nil 1499 } 1500 invalidParams := smithy.InvalidParamsError{Context: "AssociateElasticIpInput"} 1501 if v.ElasticIp == nil { 1502 invalidParams.Add(smithy.NewErrParamRequired("ElasticIp")) 1503 } 1504 if invalidParams.Len() > 0 { 1505 return invalidParams 1506 } else { 1507 return nil 1508 } 1509} 1510 1511func validateOpAttachElasticLoadBalancerInput(v *AttachElasticLoadBalancerInput) error { 1512 if v == nil { 1513 return nil 1514 } 1515 invalidParams := smithy.InvalidParamsError{Context: "AttachElasticLoadBalancerInput"} 1516 if v.ElasticLoadBalancerName == nil { 1517 invalidParams.Add(smithy.NewErrParamRequired("ElasticLoadBalancerName")) 1518 } 1519 if v.LayerId == nil { 1520 invalidParams.Add(smithy.NewErrParamRequired("LayerId")) 1521 } 1522 if invalidParams.Len() > 0 { 1523 return invalidParams 1524 } else { 1525 return nil 1526 } 1527} 1528 1529func validateOpCloneStackInput(v *CloneStackInput) error { 1530 if v == nil { 1531 return nil 1532 } 1533 invalidParams := smithy.InvalidParamsError{Context: "CloneStackInput"} 1534 if v.SourceStackId == nil { 1535 invalidParams.Add(smithy.NewErrParamRequired("SourceStackId")) 1536 } 1537 if v.ServiceRoleArn == nil { 1538 invalidParams.Add(smithy.NewErrParamRequired("ServiceRoleArn")) 1539 } 1540 if invalidParams.Len() > 0 { 1541 return invalidParams 1542 } else { 1543 return nil 1544 } 1545} 1546 1547func validateOpCreateAppInput(v *CreateAppInput) error { 1548 if v == nil { 1549 return nil 1550 } 1551 invalidParams := smithy.InvalidParamsError{Context: "CreateAppInput"} 1552 if v.StackId == nil { 1553 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 1554 } 1555 if v.Name == nil { 1556 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1557 } 1558 if len(v.Type) == 0 { 1559 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1560 } 1561 if v.SslConfiguration != nil { 1562 if err := validateSslConfiguration(v.SslConfiguration); err != nil { 1563 invalidParams.AddNested("SslConfiguration", err.(smithy.InvalidParamsError)) 1564 } 1565 } 1566 if v.Environment != nil { 1567 if err := validateEnvironmentVariables(v.Environment); err != nil { 1568 invalidParams.AddNested("Environment", err.(smithy.InvalidParamsError)) 1569 } 1570 } 1571 if invalidParams.Len() > 0 { 1572 return invalidParams 1573 } else { 1574 return nil 1575 } 1576} 1577 1578func validateOpCreateDeploymentInput(v *CreateDeploymentInput) error { 1579 if v == nil { 1580 return nil 1581 } 1582 invalidParams := smithy.InvalidParamsError{Context: "CreateDeploymentInput"} 1583 if v.StackId == nil { 1584 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 1585 } 1586 if v.Command == nil { 1587 invalidParams.Add(smithy.NewErrParamRequired("Command")) 1588 } else if v.Command != nil { 1589 if err := validateDeploymentCommand(v.Command); err != nil { 1590 invalidParams.AddNested("Command", err.(smithy.InvalidParamsError)) 1591 } 1592 } 1593 if invalidParams.Len() > 0 { 1594 return invalidParams 1595 } else { 1596 return nil 1597 } 1598} 1599 1600func validateOpCreateInstanceInput(v *CreateInstanceInput) error { 1601 if v == nil { 1602 return nil 1603 } 1604 invalidParams := smithy.InvalidParamsError{Context: "CreateInstanceInput"} 1605 if v.StackId == nil { 1606 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 1607 } 1608 if v.LayerIds == nil { 1609 invalidParams.Add(smithy.NewErrParamRequired("LayerIds")) 1610 } 1611 if v.InstanceType == nil { 1612 invalidParams.Add(smithy.NewErrParamRequired("InstanceType")) 1613 } 1614 if invalidParams.Len() > 0 { 1615 return invalidParams 1616 } else { 1617 return nil 1618 } 1619} 1620 1621func validateOpCreateLayerInput(v *CreateLayerInput) error { 1622 if v == nil { 1623 return nil 1624 } 1625 invalidParams := smithy.InvalidParamsError{Context: "CreateLayerInput"} 1626 if v.StackId == nil { 1627 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 1628 } 1629 if len(v.Type) == 0 { 1630 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1631 } 1632 if v.Name == nil { 1633 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1634 } 1635 if v.Shortname == nil { 1636 invalidParams.Add(smithy.NewErrParamRequired("Shortname")) 1637 } 1638 if v.VolumeConfigurations != nil { 1639 if err := validateVolumeConfigurations(v.VolumeConfigurations); err != nil { 1640 invalidParams.AddNested("VolumeConfigurations", err.(smithy.InvalidParamsError)) 1641 } 1642 } 1643 if invalidParams.Len() > 0 { 1644 return invalidParams 1645 } else { 1646 return nil 1647 } 1648} 1649 1650func validateOpCreateStackInput(v *CreateStackInput) error { 1651 if v == nil { 1652 return nil 1653 } 1654 invalidParams := smithy.InvalidParamsError{Context: "CreateStackInput"} 1655 if v.Name == nil { 1656 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1657 } 1658 if v.Region == nil { 1659 invalidParams.Add(smithy.NewErrParamRequired("Region")) 1660 } 1661 if v.ServiceRoleArn == nil { 1662 invalidParams.Add(smithy.NewErrParamRequired("ServiceRoleArn")) 1663 } 1664 if v.DefaultInstanceProfileArn == nil { 1665 invalidParams.Add(smithy.NewErrParamRequired("DefaultInstanceProfileArn")) 1666 } 1667 if invalidParams.Len() > 0 { 1668 return invalidParams 1669 } else { 1670 return nil 1671 } 1672} 1673 1674func validateOpCreateUserProfileInput(v *CreateUserProfileInput) error { 1675 if v == nil { 1676 return nil 1677 } 1678 invalidParams := smithy.InvalidParamsError{Context: "CreateUserProfileInput"} 1679 if v.IamUserArn == nil { 1680 invalidParams.Add(smithy.NewErrParamRequired("IamUserArn")) 1681 } 1682 if invalidParams.Len() > 0 { 1683 return invalidParams 1684 } else { 1685 return nil 1686 } 1687} 1688 1689func validateOpDeleteAppInput(v *DeleteAppInput) error { 1690 if v == nil { 1691 return nil 1692 } 1693 invalidParams := smithy.InvalidParamsError{Context: "DeleteAppInput"} 1694 if v.AppId == nil { 1695 invalidParams.Add(smithy.NewErrParamRequired("AppId")) 1696 } 1697 if invalidParams.Len() > 0 { 1698 return invalidParams 1699 } else { 1700 return nil 1701 } 1702} 1703 1704func validateOpDeleteInstanceInput(v *DeleteInstanceInput) error { 1705 if v == nil { 1706 return nil 1707 } 1708 invalidParams := smithy.InvalidParamsError{Context: "DeleteInstanceInput"} 1709 if v.InstanceId == nil { 1710 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 1711 } 1712 if invalidParams.Len() > 0 { 1713 return invalidParams 1714 } else { 1715 return nil 1716 } 1717} 1718 1719func validateOpDeleteLayerInput(v *DeleteLayerInput) error { 1720 if v == nil { 1721 return nil 1722 } 1723 invalidParams := smithy.InvalidParamsError{Context: "DeleteLayerInput"} 1724 if v.LayerId == nil { 1725 invalidParams.Add(smithy.NewErrParamRequired("LayerId")) 1726 } 1727 if invalidParams.Len() > 0 { 1728 return invalidParams 1729 } else { 1730 return nil 1731 } 1732} 1733 1734func validateOpDeleteStackInput(v *DeleteStackInput) error { 1735 if v == nil { 1736 return nil 1737 } 1738 invalidParams := smithy.InvalidParamsError{Context: "DeleteStackInput"} 1739 if v.StackId == nil { 1740 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 1741 } 1742 if invalidParams.Len() > 0 { 1743 return invalidParams 1744 } else { 1745 return nil 1746 } 1747} 1748 1749func validateOpDeleteUserProfileInput(v *DeleteUserProfileInput) error { 1750 if v == nil { 1751 return nil 1752 } 1753 invalidParams := smithy.InvalidParamsError{Context: "DeleteUserProfileInput"} 1754 if v.IamUserArn == nil { 1755 invalidParams.Add(smithy.NewErrParamRequired("IamUserArn")) 1756 } 1757 if invalidParams.Len() > 0 { 1758 return invalidParams 1759 } else { 1760 return nil 1761 } 1762} 1763 1764func validateOpDeregisterEcsClusterInput(v *DeregisterEcsClusterInput) error { 1765 if v == nil { 1766 return nil 1767 } 1768 invalidParams := smithy.InvalidParamsError{Context: "DeregisterEcsClusterInput"} 1769 if v.EcsClusterArn == nil { 1770 invalidParams.Add(smithy.NewErrParamRequired("EcsClusterArn")) 1771 } 1772 if invalidParams.Len() > 0 { 1773 return invalidParams 1774 } else { 1775 return nil 1776 } 1777} 1778 1779func validateOpDeregisterElasticIpInput(v *DeregisterElasticIpInput) error { 1780 if v == nil { 1781 return nil 1782 } 1783 invalidParams := smithy.InvalidParamsError{Context: "DeregisterElasticIpInput"} 1784 if v.ElasticIp == nil { 1785 invalidParams.Add(smithy.NewErrParamRequired("ElasticIp")) 1786 } 1787 if invalidParams.Len() > 0 { 1788 return invalidParams 1789 } else { 1790 return nil 1791 } 1792} 1793 1794func validateOpDeregisterInstanceInput(v *DeregisterInstanceInput) error { 1795 if v == nil { 1796 return nil 1797 } 1798 invalidParams := smithy.InvalidParamsError{Context: "DeregisterInstanceInput"} 1799 if v.InstanceId == nil { 1800 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 1801 } 1802 if invalidParams.Len() > 0 { 1803 return invalidParams 1804 } else { 1805 return nil 1806 } 1807} 1808 1809func validateOpDeregisterRdsDbInstanceInput(v *DeregisterRdsDbInstanceInput) error { 1810 if v == nil { 1811 return nil 1812 } 1813 invalidParams := smithy.InvalidParamsError{Context: "DeregisterRdsDbInstanceInput"} 1814 if v.RdsDbInstanceArn == nil { 1815 invalidParams.Add(smithy.NewErrParamRequired("RdsDbInstanceArn")) 1816 } 1817 if invalidParams.Len() > 0 { 1818 return invalidParams 1819 } else { 1820 return nil 1821 } 1822} 1823 1824func validateOpDeregisterVolumeInput(v *DeregisterVolumeInput) error { 1825 if v == nil { 1826 return nil 1827 } 1828 invalidParams := smithy.InvalidParamsError{Context: "DeregisterVolumeInput"} 1829 if v.VolumeId == nil { 1830 invalidParams.Add(smithy.NewErrParamRequired("VolumeId")) 1831 } 1832 if invalidParams.Len() > 0 { 1833 return invalidParams 1834 } else { 1835 return nil 1836 } 1837} 1838 1839func validateOpDescribeLoadBasedAutoScalingInput(v *DescribeLoadBasedAutoScalingInput) error { 1840 if v == nil { 1841 return nil 1842 } 1843 invalidParams := smithy.InvalidParamsError{Context: "DescribeLoadBasedAutoScalingInput"} 1844 if v.LayerIds == nil { 1845 invalidParams.Add(smithy.NewErrParamRequired("LayerIds")) 1846 } 1847 if invalidParams.Len() > 0 { 1848 return invalidParams 1849 } else { 1850 return nil 1851 } 1852} 1853 1854func validateOpDescribeRdsDbInstancesInput(v *DescribeRdsDbInstancesInput) error { 1855 if v == nil { 1856 return nil 1857 } 1858 invalidParams := smithy.InvalidParamsError{Context: "DescribeRdsDbInstancesInput"} 1859 if v.StackId == nil { 1860 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 1861 } 1862 if invalidParams.Len() > 0 { 1863 return invalidParams 1864 } else { 1865 return nil 1866 } 1867} 1868 1869func validateOpDescribeStackProvisioningParametersInput(v *DescribeStackProvisioningParametersInput) error { 1870 if v == nil { 1871 return nil 1872 } 1873 invalidParams := smithy.InvalidParamsError{Context: "DescribeStackProvisioningParametersInput"} 1874 if v.StackId == nil { 1875 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 1876 } 1877 if invalidParams.Len() > 0 { 1878 return invalidParams 1879 } else { 1880 return nil 1881 } 1882} 1883 1884func validateOpDescribeStackSummaryInput(v *DescribeStackSummaryInput) error { 1885 if v == nil { 1886 return nil 1887 } 1888 invalidParams := smithy.InvalidParamsError{Context: "DescribeStackSummaryInput"} 1889 if v.StackId == nil { 1890 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 1891 } 1892 if invalidParams.Len() > 0 { 1893 return invalidParams 1894 } else { 1895 return nil 1896 } 1897} 1898 1899func validateOpDescribeTimeBasedAutoScalingInput(v *DescribeTimeBasedAutoScalingInput) error { 1900 if v == nil { 1901 return nil 1902 } 1903 invalidParams := smithy.InvalidParamsError{Context: "DescribeTimeBasedAutoScalingInput"} 1904 if v.InstanceIds == nil { 1905 invalidParams.Add(smithy.NewErrParamRequired("InstanceIds")) 1906 } 1907 if invalidParams.Len() > 0 { 1908 return invalidParams 1909 } else { 1910 return nil 1911 } 1912} 1913 1914func validateOpDetachElasticLoadBalancerInput(v *DetachElasticLoadBalancerInput) error { 1915 if v == nil { 1916 return nil 1917 } 1918 invalidParams := smithy.InvalidParamsError{Context: "DetachElasticLoadBalancerInput"} 1919 if v.ElasticLoadBalancerName == nil { 1920 invalidParams.Add(smithy.NewErrParamRequired("ElasticLoadBalancerName")) 1921 } 1922 if v.LayerId == nil { 1923 invalidParams.Add(smithy.NewErrParamRequired("LayerId")) 1924 } 1925 if invalidParams.Len() > 0 { 1926 return invalidParams 1927 } else { 1928 return nil 1929 } 1930} 1931 1932func validateOpDisassociateElasticIpInput(v *DisassociateElasticIpInput) error { 1933 if v == nil { 1934 return nil 1935 } 1936 invalidParams := smithy.InvalidParamsError{Context: "DisassociateElasticIpInput"} 1937 if v.ElasticIp == nil { 1938 invalidParams.Add(smithy.NewErrParamRequired("ElasticIp")) 1939 } 1940 if invalidParams.Len() > 0 { 1941 return invalidParams 1942 } else { 1943 return nil 1944 } 1945} 1946 1947func validateOpGetHostnameSuggestionInput(v *GetHostnameSuggestionInput) error { 1948 if v == nil { 1949 return nil 1950 } 1951 invalidParams := smithy.InvalidParamsError{Context: "GetHostnameSuggestionInput"} 1952 if v.LayerId == nil { 1953 invalidParams.Add(smithy.NewErrParamRequired("LayerId")) 1954 } 1955 if invalidParams.Len() > 0 { 1956 return invalidParams 1957 } else { 1958 return nil 1959 } 1960} 1961 1962func validateOpGrantAccessInput(v *GrantAccessInput) error { 1963 if v == nil { 1964 return nil 1965 } 1966 invalidParams := smithy.InvalidParamsError{Context: "GrantAccessInput"} 1967 if v.InstanceId == nil { 1968 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 1969 } 1970 if invalidParams.Len() > 0 { 1971 return invalidParams 1972 } else { 1973 return nil 1974 } 1975} 1976 1977func validateOpListTagsInput(v *ListTagsInput) error { 1978 if v == nil { 1979 return nil 1980 } 1981 invalidParams := smithy.InvalidParamsError{Context: "ListTagsInput"} 1982 if v.ResourceArn == nil { 1983 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1984 } 1985 if invalidParams.Len() > 0 { 1986 return invalidParams 1987 } else { 1988 return nil 1989 } 1990} 1991 1992func validateOpRebootInstanceInput(v *RebootInstanceInput) error { 1993 if v == nil { 1994 return nil 1995 } 1996 invalidParams := smithy.InvalidParamsError{Context: "RebootInstanceInput"} 1997 if v.InstanceId == nil { 1998 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 1999 } 2000 if invalidParams.Len() > 0 { 2001 return invalidParams 2002 } else { 2003 return nil 2004 } 2005} 2006 2007func validateOpRegisterEcsClusterInput(v *RegisterEcsClusterInput) error { 2008 if v == nil { 2009 return nil 2010 } 2011 invalidParams := smithy.InvalidParamsError{Context: "RegisterEcsClusterInput"} 2012 if v.EcsClusterArn == nil { 2013 invalidParams.Add(smithy.NewErrParamRequired("EcsClusterArn")) 2014 } 2015 if v.StackId == nil { 2016 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 2017 } 2018 if invalidParams.Len() > 0 { 2019 return invalidParams 2020 } else { 2021 return nil 2022 } 2023} 2024 2025func validateOpRegisterElasticIpInput(v *RegisterElasticIpInput) error { 2026 if v == nil { 2027 return nil 2028 } 2029 invalidParams := smithy.InvalidParamsError{Context: "RegisterElasticIpInput"} 2030 if v.ElasticIp == nil { 2031 invalidParams.Add(smithy.NewErrParamRequired("ElasticIp")) 2032 } 2033 if v.StackId == nil { 2034 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 2035 } 2036 if invalidParams.Len() > 0 { 2037 return invalidParams 2038 } else { 2039 return nil 2040 } 2041} 2042 2043func validateOpRegisterInstanceInput(v *RegisterInstanceInput) error { 2044 if v == nil { 2045 return nil 2046 } 2047 invalidParams := smithy.InvalidParamsError{Context: "RegisterInstanceInput"} 2048 if v.StackId == nil { 2049 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 2050 } 2051 if invalidParams.Len() > 0 { 2052 return invalidParams 2053 } else { 2054 return nil 2055 } 2056} 2057 2058func validateOpRegisterRdsDbInstanceInput(v *RegisterRdsDbInstanceInput) error { 2059 if v == nil { 2060 return nil 2061 } 2062 invalidParams := smithy.InvalidParamsError{Context: "RegisterRdsDbInstanceInput"} 2063 if v.StackId == nil { 2064 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 2065 } 2066 if v.RdsDbInstanceArn == nil { 2067 invalidParams.Add(smithy.NewErrParamRequired("RdsDbInstanceArn")) 2068 } 2069 if v.DbUser == nil { 2070 invalidParams.Add(smithy.NewErrParamRequired("DbUser")) 2071 } 2072 if v.DbPassword == nil { 2073 invalidParams.Add(smithy.NewErrParamRequired("DbPassword")) 2074 } 2075 if invalidParams.Len() > 0 { 2076 return invalidParams 2077 } else { 2078 return nil 2079 } 2080} 2081 2082func validateOpRegisterVolumeInput(v *RegisterVolumeInput) error { 2083 if v == nil { 2084 return nil 2085 } 2086 invalidParams := smithy.InvalidParamsError{Context: "RegisterVolumeInput"} 2087 if v.StackId == nil { 2088 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 2089 } 2090 if invalidParams.Len() > 0 { 2091 return invalidParams 2092 } else { 2093 return nil 2094 } 2095} 2096 2097func validateOpSetLoadBasedAutoScalingInput(v *SetLoadBasedAutoScalingInput) error { 2098 if v == nil { 2099 return nil 2100 } 2101 invalidParams := smithy.InvalidParamsError{Context: "SetLoadBasedAutoScalingInput"} 2102 if v.LayerId == nil { 2103 invalidParams.Add(smithy.NewErrParamRequired("LayerId")) 2104 } 2105 if invalidParams.Len() > 0 { 2106 return invalidParams 2107 } else { 2108 return nil 2109 } 2110} 2111 2112func validateOpSetPermissionInput(v *SetPermissionInput) error { 2113 if v == nil { 2114 return nil 2115 } 2116 invalidParams := smithy.InvalidParamsError{Context: "SetPermissionInput"} 2117 if v.StackId == nil { 2118 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 2119 } 2120 if v.IamUserArn == nil { 2121 invalidParams.Add(smithy.NewErrParamRequired("IamUserArn")) 2122 } 2123 if invalidParams.Len() > 0 { 2124 return invalidParams 2125 } else { 2126 return nil 2127 } 2128} 2129 2130func validateOpSetTimeBasedAutoScalingInput(v *SetTimeBasedAutoScalingInput) error { 2131 if v == nil { 2132 return nil 2133 } 2134 invalidParams := smithy.InvalidParamsError{Context: "SetTimeBasedAutoScalingInput"} 2135 if v.InstanceId == nil { 2136 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 2137 } 2138 if invalidParams.Len() > 0 { 2139 return invalidParams 2140 } else { 2141 return nil 2142 } 2143} 2144 2145func validateOpStartInstanceInput(v *StartInstanceInput) error { 2146 if v == nil { 2147 return nil 2148 } 2149 invalidParams := smithy.InvalidParamsError{Context: "StartInstanceInput"} 2150 if v.InstanceId == nil { 2151 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 2152 } 2153 if invalidParams.Len() > 0 { 2154 return invalidParams 2155 } else { 2156 return nil 2157 } 2158} 2159 2160func validateOpStartStackInput(v *StartStackInput) error { 2161 if v == nil { 2162 return nil 2163 } 2164 invalidParams := smithy.InvalidParamsError{Context: "StartStackInput"} 2165 if v.StackId == nil { 2166 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 2167 } 2168 if invalidParams.Len() > 0 { 2169 return invalidParams 2170 } else { 2171 return nil 2172 } 2173} 2174 2175func validateOpStopInstanceInput(v *StopInstanceInput) error { 2176 if v == nil { 2177 return nil 2178 } 2179 invalidParams := smithy.InvalidParamsError{Context: "StopInstanceInput"} 2180 if v.InstanceId == nil { 2181 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 2182 } 2183 if invalidParams.Len() > 0 { 2184 return invalidParams 2185 } else { 2186 return nil 2187 } 2188} 2189 2190func validateOpStopStackInput(v *StopStackInput) error { 2191 if v == nil { 2192 return nil 2193 } 2194 invalidParams := smithy.InvalidParamsError{Context: "StopStackInput"} 2195 if v.StackId == nil { 2196 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 2197 } 2198 if invalidParams.Len() > 0 { 2199 return invalidParams 2200 } else { 2201 return nil 2202 } 2203} 2204 2205func validateOpTagResourceInput(v *TagResourceInput) error { 2206 if v == nil { 2207 return nil 2208 } 2209 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 2210 if v.ResourceArn == nil { 2211 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2212 } 2213 if v.Tags == nil { 2214 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 2215 } 2216 if invalidParams.Len() > 0 { 2217 return invalidParams 2218 } else { 2219 return nil 2220 } 2221} 2222 2223func validateOpUnassignInstanceInput(v *UnassignInstanceInput) error { 2224 if v == nil { 2225 return nil 2226 } 2227 invalidParams := smithy.InvalidParamsError{Context: "UnassignInstanceInput"} 2228 if v.InstanceId == nil { 2229 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 2230 } 2231 if invalidParams.Len() > 0 { 2232 return invalidParams 2233 } else { 2234 return nil 2235 } 2236} 2237 2238func validateOpUnassignVolumeInput(v *UnassignVolumeInput) error { 2239 if v == nil { 2240 return nil 2241 } 2242 invalidParams := smithy.InvalidParamsError{Context: "UnassignVolumeInput"} 2243 if v.VolumeId == nil { 2244 invalidParams.Add(smithy.NewErrParamRequired("VolumeId")) 2245 } 2246 if invalidParams.Len() > 0 { 2247 return invalidParams 2248 } else { 2249 return nil 2250 } 2251} 2252 2253func validateOpUntagResourceInput(v *UntagResourceInput) error { 2254 if v == nil { 2255 return nil 2256 } 2257 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 2258 if v.ResourceArn == nil { 2259 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2260 } 2261 if v.TagKeys == nil { 2262 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 2263 } 2264 if invalidParams.Len() > 0 { 2265 return invalidParams 2266 } else { 2267 return nil 2268 } 2269} 2270 2271func validateOpUpdateAppInput(v *UpdateAppInput) error { 2272 if v == nil { 2273 return nil 2274 } 2275 invalidParams := smithy.InvalidParamsError{Context: "UpdateAppInput"} 2276 if v.AppId == nil { 2277 invalidParams.Add(smithy.NewErrParamRequired("AppId")) 2278 } 2279 if v.SslConfiguration != nil { 2280 if err := validateSslConfiguration(v.SslConfiguration); err != nil { 2281 invalidParams.AddNested("SslConfiguration", err.(smithy.InvalidParamsError)) 2282 } 2283 } 2284 if v.Environment != nil { 2285 if err := validateEnvironmentVariables(v.Environment); err != nil { 2286 invalidParams.AddNested("Environment", err.(smithy.InvalidParamsError)) 2287 } 2288 } 2289 if invalidParams.Len() > 0 { 2290 return invalidParams 2291 } else { 2292 return nil 2293 } 2294} 2295 2296func validateOpUpdateElasticIpInput(v *UpdateElasticIpInput) error { 2297 if v == nil { 2298 return nil 2299 } 2300 invalidParams := smithy.InvalidParamsError{Context: "UpdateElasticIpInput"} 2301 if v.ElasticIp == nil { 2302 invalidParams.Add(smithy.NewErrParamRequired("ElasticIp")) 2303 } 2304 if invalidParams.Len() > 0 { 2305 return invalidParams 2306 } else { 2307 return nil 2308 } 2309} 2310 2311func validateOpUpdateInstanceInput(v *UpdateInstanceInput) error { 2312 if v == nil { 2313 return nil 2314 } 2315 invalidParams := smithy.InvalidParamsError{Context: "UpdateInstanceInput"} 2316 if v.InstanceId == nil { 2317 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 2318 } 2319 if invalidParams.Len() > 0 { 2320 return invalidParams 2321 } else { 2322 return nil 2323 } 2324} 2325 2326func validateOpUpdateLayerInput(v *UpdateLayerInput) error { 2327 if v == nil { 2328 return nil 2329 } 2330 invalidParams := smithy.InvalidParamsError{Context: "UpdateLayerInput"} 2331 if v.LayerId == nil { 2332 invalidParams.Add(smithy.NewErrParamRequired("LayerId")) 2333 } 2334 if v.VolumeConfigurations != nil { 2335 if err := validateVolumeConfigurations(v.VolumeConfigurations); err != nil { 2336 invalidParams.AddNested("VolumeConfigurations", err.(smithy.InvalidParamsError)) 2337 } 2338 } 2339 if invalidParams.Len() > 0 { 2340 return invalidParams 2341 } else { 2342 return nil 2343 } 2344} 2345 2346func validateOpUpdateRdsDbInstanceInput(v *UpdateRdsDbInstanceInput) error { 2347 if v == nil { 2348 return nil 2349 } 2350 invalidParams := smithy.InvalidParamsError{Context: "UpdateRdsDbInstanceInput"} 2351 if v.RdsDbInstanceArn == nil { 2352 invalidParams.Add(smithy.NewErrParamRequired("RdsDbInstanceArn")) 2353 } 2354 if invalidParams.Len() > 0 { 2355 return invalidParams 2356 } else { 2357 return nil 2358 } 2359} 2360 2361func validateOpUpdateStackInput(v *UpdateStackInput) error { 2362 if v == nil { 2363 return nil 2364 } 2365 invalidParams := smithy.InvalidParamsError{Context: "UpdateStackInput"} 2366 if v.StackId == nil { 2367 invalidParams.Add(smithy.NewErrParamRequired("StackId")) 2368 } 2369 if invalidParams.Len() > 0 { 2370 return invalidParams 2371 } else { 2372 return nil 2373 } 2374} 2375 2376func validateOpUpdateUserProfileInput(v *UpdateUserProfileInput) error { 2377 if v == nil { 2378 return nil 2379 } 2380 invalidParams := smithy.InvalidParamsError{Context: "UpdateUserProfileInput"} 2381 if v.IamUserArn == nil { 2382 invalidParams.Add(smithy.NewErrParamRequired("IamUserArn")) 2383 } 2384 if invalidParams.Len() > 0 { 2385 return invalidParams 2386 } else { 2387 return nil 2388 } 2389} 2390 2391func validateOpUpdateVolumeInput(v *UpdateVolumeInput) error { 2392 if v == nil { 2393 return nil 2394 } 2395 invalidParams := smithy.InvalidParamsError{Context: "UpdateVolumeInput"} 2396 if v.VolumeId == nil { 2397 invalidParams.Add(smithy.NewErrParamRequired("VolumeId")) 2398 } 2399 if invalidParams.Len() > 0 { 2400 return invalidParams 2401 } else { 2402 return nil 2403 } 2404} 2405