1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package organizations 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/organizations/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpAcceptHandshake struct { 14} 15 16func (*validateOpAcceptHandshake) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpAcceptHandshake) 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.(*AcceptHandshakeInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpAcceptHandshakeInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpAttachPolicy struct { 34} 35 36func (*validateOpAttachPolicy) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpAttachPolicy) 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.(*AttachPolicyInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpAttachPolicyInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCancelHandshake struct { 54} 55 56func (*validateOpCancelHandshake) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCancelHandshake) 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.(*CancelHandshakeInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCancelHandshakeInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateAccount struct { 74} 75 76func (*validateOpCreateAccount) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateAccount) 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.(*CreateAccountInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateAccountInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateGovCloudAccount struct { 94} 95 96func (*validateOpCreateGovCloudAccount) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateGovCloudAccount) 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.(*CreateGovCloudAccountInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateGovCloudAccountInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateOrganizationalUnit struct { 114} 115 116func (*validateOpCreateOrganizationalUnit) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateOrganizationalUnit) 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.(*CreateOrganizationalUnitInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateOrganizationalUnitInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpCreatePolicy struct { 134} 135 136func (*validateOpCreatePolicy) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpCreatePolicy) 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.(*CreatePolicyInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpCreatePolicyInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeclineHandshake struct { 154} 155 156func (*validateOpDeclineHandshake) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeclineHandshake) 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.(*DeclineHandshakeInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeclineHandshakeInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDeleteOrganizationalUnit struct { 174} 175 176func (*validateOpDeleteOrganizationalUnit) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDeleteOrganizationalUnit) 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.(*DeleteOrganizationalUnitInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDeleteOrganizationalUnitInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDeletePolicy struct { 194} 195 196func (*validateOpDeletePolicy) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDeletePolicy) 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.(*DeletePolicyInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDeletePolicyInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDeregisterDelegatedAdministrator struct { 214} 215 216func (*validateOpDeregisterDelegatedAdministrator) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDeregisterDelegatedAdministrator) 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.(*DeregisterDelegatedAdministratorInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDeregisterDelegatedAdministratorInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDescribeAccount struct { 234} 235 236func (*validateOpDescribeAccount) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDescribeAccount) 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.(*DescribeAccountInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDescribeAccountInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDescribeCreateAccountStatus struct { 254} 255 256func (*validateOpDescribeCreateAccountStatus) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDescribeCreateAccountStatus) 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.(*DescribeCreateAccountStatusInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDescribeCreateAccountStatusInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDescribeEffectivePolicy struct { 274} 275 276func (*validateOpDescribeEffectivePolicy) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDescribeEffectivePolicy) 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.(*DescribeEffectivePolicyInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDescribeEffectivePolicyInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpDescribeHandshake struct { 294} 295 296func (*validateOpDescribeHandshake) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpDescribeHandshake) 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.(*DescribeHandshakeInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpDescribeHandshakeInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpDescribeOrganizationalUnit struct { 314} 315 316func (*validateOpDescribeOrganizationalUnit) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpDescribeOrganizationalUnit) 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.(*DescribeOrganizationalUnitInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpDescribeOrganizationalUnitInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpDescribePolicy struct { 334} 335 336func (*validateOpDescribePolicy) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpDescribePolicy) 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.(*DescribePolicyInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpDescribePolicyInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpDetachPolicy struct { 354} 355 356func (*validateOpDetachPolicy) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpDetachPolicy) 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.(*DetachPolicyInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpDetachPolicyInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpDisableAWSServiceAccess struct { 374} 375 376func (*validateOpDisableAWSServiceAccess) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpDisableAWSServiceAccess) 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.(*DisableAWSServiceAccessInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpDisableAWSServiceAccessInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpDisablePolicyType struct { 394} 395 396func (*validateOpDisablePolicyType) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpDisablePolicyType) 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.(*DisablePolicyTypeInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpDisablePolicyTypeInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpEnableAWSServiceAccess struct { 414} 415 416func (*validateOpEnableAWSServiceAccess) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpEnableAWSServiceAccess) 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.(*EnableAWSServiceAccessInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpEnableAWSServiceAccessInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpEnablePolicyType struct { 434} 435 436func (*validateOpEnablePolicyType) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpEnablePolicyType) 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.(*EnablePolicyTypeInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpEnablePolicyTypeInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpInviteAccountToOrganization struct { 454} 455 456func (*validateOpInviteAccountToOrganization) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpInviteAccountToOrganization) 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.(*InviteAccountToOrganizationInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpInviteAccountToOrganizationInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpListAccountsForParent struct { 474} 475 476func (*validateOpListAccountsForParent) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpListAccountsForParent) 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.(*ListAccountsForParentInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpListAccountsForParentInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpListChildren struct { 494} 495 496func (*validateOpListChildren) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpListChildren) 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.(*ListChildrenInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpListChildrenInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpListDelegatedServicesForAccount struct { 514} 515 516func (*validateOpListDelegatedServicesForAccount) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpListDelegatedServicesForAccount) 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.(*ListDelegatedServicesForAccountInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpListDelegatedServicesForAccountInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpListOrganizationalUnitsForParent struct { 534} 535 536func (*validateOpListOrganizationalUnitsForParent) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpListOrganizationalUnitsForParent) 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.(*ListOrganizationalUnitsForParentInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpListOrganizationalUnitsForParentInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpListParents struct { 554} 555 556func (*validateOpListParents) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpListParents) 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.(*ListParentsInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpListParentsInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpListPoliciesForTarget struct { 574} 575 576func (*validateOpListPoliciesForTarget) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpListPoliciesForTarget) 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.(*ListPoliciesForTargetInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpListPoliciesForTargetInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpListPolicies struct { 594} 595 596func (*validateOpListPolicies) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpListPolicies) 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.(*ListPoliciesInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpListPoliciesInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpListTagsForResource struct { 614} 615 616func (*validateOpListTagsForResource) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpListTagsForResourceInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpListTargetsForPolicy struct { 634} 635 636func (*validateOpListTargetsForPolicy) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpListTargetsForPolicy) 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.(*ListTargetsForPolicyInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpListTargetsForPolicyInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpMoveAccount struct { 654} 655 656func (*validateOpMoveAccount) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpMoveAccount) 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.(*MoveAccountInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpMoveAccountInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpRegisterDelegatedAdministrator struct { 674} 675 676func (*validateOpRegisterDelegatedAdministrator) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpRegisterDelegatedAdministrator) 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.(*RegisterDelegatedAdministratorInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpRegisterDelegatedAdministratorInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpRemoveAccountFromOrganization struct { 694} 695 696func (*validateOpRemoveAccountFromOrganization) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpRemoveAccountFromOrganization) 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.(*RemoveAccountFromOrganizationInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpRemoveAccountFromOrganizationInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpTagResource struct { 714} 715 716func (*validateOpTagResource) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpTagResource) 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.(*TagResourceInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpTagResourceInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpUntagResource struct { 734} 735 736func (*validateOpUntagResource) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpUntagResource) 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.(*UntagResourceInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpUntagResourceInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753type validateOpUpdateOrganizationalUnit struct { 754} 755 756func (*validateOpUpdateOrganizationalUnit) ID() string { 757 return "OperationInputValidation" 758} 759 760func (m *validateOpUpdateOrganizationalUnit) 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.(*UpdateOrganizationalUnitInput) 764 if !ok { 765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 766 } 767 if err := validateOpUpdateOrganizationalUnitInput(input); err != nil { 768 return out, metadata, err 769 } 770 return next.HandleInitialize(ctx, in) 771} 772 773type validateOpUpdatePolicy struct { 774} 775 776func (*validateOpUpdatePolicy) ID() string { 777 return "OperationInputValidation" 778} 779 780func (m *validateOpUpdatePolicy) 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.(*UpdatePolicyInput) 784 if !ok { 785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 786 } 787 if err := validateOpUpdatePolicyInput(input); err != nil { 788 return out, metadata, err 789 } 790 return next.HandleInitialize(ctx, in) 791} 792 793func addOpAcceptHandshakeValidationMiddleware(stack *middleware.Stack) error { 794 return stack.Initialize.Add(&validateOpAcceptHandshake{}, middleware.After) 795} 796 797func addOpAttachPolicyValidationMiddleware(stack *middleware.Stack) error { 798 return stack.Initialize.Add(&validateOpAttachPolicy{}, middleware.After) 799} 800 801func addOpCancelHandshakeValidationMiddleware(stack *middleware.Stack) error { 802 return stack.Initialize.Add(&validateOpCancelHandshake{}, middleware.After) 803} 804 805func addOpCreateAccountValidationMiddleware(stack *middleware.Stack) error { 806 return stack.Initialize.Add(&validateOpCreateAccount{}, middleware.After) 807} 808 809func addOpCreateGovCloudAccountValidationMiddleware(stack *middleware.Stack) error { 810 return stack.Initialize.Add(&validateOpCreateGovCloudAccount{}, middleware.After) 811} 812 813func addOpCreateOrganizationalUnitValidationMiddleware(stack *middleware.Stack) error { 814 return stack.Initialize.Add(&validateOpCreateOrganizationalUnit{}, middleware.After) 815} 816 817func addOpCreatePolicyValidationMiddleware(stack *middleware.Stack) error { 818 return stack.Initialize.Add(&validateOpCreatePolicy{}, middleware.After) 819} 820 821func addOpDeclineHandshakeValidationMiddleware(stack *middleware.Stack) error { 822 return stack.Initialize.Add(&validateOpDeclineHandshake{}, middleware.After) 823} 824 825func addOpDeleteOrganizationalUnitValidationMiddleware(stack *middleware.Stack) error { 826 return stack.Initialize.Add(&validateOpDeleteOrganizationalUnit{}, middleware.After) 827} 828 829func addOpDeletePolicyValidationMiddleware(stack *middleware.Stack) error { 830 return stack.Initialize.Add(&validateOpDeletePolicy{}, middleware.After) 831} 832 833func addOpDeregisterDelegatedAdministratorValidationMiddleware(stack *middleware.Stack) error { 834 return stack.Initialize.Add(&validateOpDeregisterDelegatedAdministrator{}, middleware.After) 835} 836 837func addOpDescribeAccountValidationMiddleware(stack *middleware.Stack) error { 838 return stack.Initialize.Add(&validateOpDescribeAccount{}, middleware.After) 839} 840 841func addOpDescribeCreateAccountStatusValidationMiddleware(stack *middleware.Stack) error { 842 return stack.Initialize.Add(&validateOpDescribeCreateAccountStatus{}, middleware.After) 843} 844 845func addOpDescribeEffectivePolicyValidationMiddleware(stack *middleware.Stack) error { 846 return stack.Initialize.Add(&validateOpDescribeEffectivePolicy{}, middleware.After) 847} 848 849func addOpDescribeHandshakeValidationMiddleware(stack *middleware.Stack) error { 850 return stack.Initialize.Add(&validateOpDescribeHandshake{}, middleware.After) 851} 852 853func addOpDescribeOrganizationalUnitValidationMiddleware(stack *middleware.Stack) error { 854 return stack.Initialize.Add(&validateOpDescribeOrganizationalUnit{}, middleware.After) 855} 856 857func addOpDescribePolicyValidationMiddleware(stack *middleware.Stack) error { 858 return stack.Initialize.Add(&validateOpDescribePolicy{}, middleware.After) 859} 860 861func addOpDetachPolicyValidationMiddleware(stack *middleware.Stack) error { 862 return stack.Initialize.Add(&validateOpDetachPolicy{}, middleware.After) 863} 864 865func addOpDisableAWSServiceAccessValidationMiddleware(stack *middleware.Stack) error { 866 return stack.Initialize.Add(&validateOpDisableAWSServiceAccess{}, middleware.After) 867} 868 869func addOpDisablePolicyTypeValidationMiddleware(stack *middleware.Stack) error { 870 return stack.Initialize.Add(&validateOpDisablePolicyType{}, middleware.After) 871} 872 873func addOpEnableAWSServiceAccessValidationMiddleware(stack *middleware.Stack) error { 874 return stack.Initialize.Add(&validateOpEnableAWSServiceAccess{}, middleware.After) 875} 876 877func addOpEnablePolicyTypeValidationMiddleware(stack *middleware.Stack) error { 878 return stack.Initialize.Add(&validateOpEnablePolicyType{}, middleware.After) 879} 880 881func addOpInviteAccountToOrganizationValidationMiddleware(stack *middleware.Stack) error { 882 return stack.Initialize.Add(&validateOpInviteAccountToOrganization{}, middleware.After) 883} 884 885func addOpListAccountsForParentValidationMiddleware(stack *middleware.Stack) error { 886 return stack.Initialize.Add(&validateOpListAccountsForParent{}, middleware.After) 887} 888 889func addOpListChildrenValidationMiddleware(stack *middleware.Stack) error { 890 return stack.Initialize.Add(&validateOpListChildren{}, middleware.After) 891} 892 893func addOpListDelegatedServicesForAccountValidationMiddleware(stack *middleware.Stack) error { 894 return stack.Initialize.Add(&validateOpListDelegatedServicesForAccount{}, middleware.After) 895} 896 897func addOpListOrganizationalUnitsForParentValidationMiddleware(stack *middleware.Stack) error { 898 return stack.Initialize.Add(&validateOpListOrganizationalUnitsForParent{}, middleware.After) 899} 900 901func addOpListParentsValidationMiddleware(stack *middleware.Stack) error { 902 return stack.Initialize.Add(&validateOpListParents{}, middleware.After) 903} 904 905func addOpListPoliciesForTargetValidationMiddleware(stack *middleware.Stack) error { 906 return stack.Initialize.Add(&validateOpListPoliciesForTarget{}, middleware.After) 907} 908 909func addOpListPoliciesValidationMiddleware(stack *middleware.Stack) error { 910 return stack.Initialize.Add(&validateOpListPolicies{}, middleware.After) 911} 912 913func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 914 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 915} 916 917func addOpListTargetsForPolicyValidationMiddleware(stack *middleware.Stack) error { 918 return stack.Initialize.Add(&validateOpListTargetsForPolicy{}, middleware.After) 919} 920 921func addOpMoveAccountValidationMiddleware(stack *middleware.Stack) error { 922 return stack.Initialize.Add(&validateOpMoveAccount{}, middleware.After) 923} 924 925func addOpRegisterDelegatedAdministratorValidationMiddleware(stack *middleware.Stack) error { 926 return stack.Initialize.Add(&validateOpRegisterDelegatedAdministrator{}, middleware.After) 927} 928 929func addOpRemoveAccountFromOrganizationValidationMiddleware(stack *middleware.Stack) error { 930 return stack.Initialize.Add(&validateOpRemoveAccountFromOrganization{}, middleware.After) 931} 932 933func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 934 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 935} 936 937func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 938 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 939} 940 941func addOpUpdateOrganizationalUnitValidationMiddleware(stack *middleware.Stack) error { 942 return stack.Initialize.Add(&validateOpUpdateOrganizationalUnit{}, middleware.After) 943} 944 945func addOpUpdatePolicyValidationMiddleware(stack *middleware.Stack) error { 946 return stack.Initialize.Add(&validateOpUpdatePolicy{}, middleware.After) 947} 948 949func validateHandshakeParty(v *types.HandshakeParty) error { 950 if v == nil { 951 return nil 952 } 953 invalidParams := smithy.InvalidParamsError{Context: "HandshakeParty"} 954 if v.Id == nil { 955 invalidParams.Add(smithy.NewErrParamRequired("Id")) 956 } 957 if len(v.Type) == 0 { 958 invalidParams.Add(smithy.NewErrParamRequired("Type")) 959 } 960 if invalidParams.Len() > 0 { 961 return invalidParams 962 } else { 963 return nil 964 } 965} 966 967func validateTag(v *types.Tag) error { 968 if v == nil { 969 return nil 970 } 971 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 972 if v.Key == nil { 973 invalidParams.Add(smithy.NewErrParamRequired("Key")) 974 } 975 if v.Value == nil { 976 invalidParams.Add(smithy.NewErrParamRequired("Value")) 977 } 978 if invalidParams.Len() > 0 { 979 return invalidParams 980 } else { 981 return nil 982 } 983} 984 985func validateTags(v []types.Tag) error { 986 if v == nil { 987 return nil 988 } 989 invalidParams := smithy.InvalidParamsError{Context: "Tags"} 990 for i := range v { 991 if err := validateTag(&v[i]); err != nil { 992 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 993 } 994 } 995 if invalidParams.Len() > 0 { 996 return invalidParams 997 } else { 998 return nil 999 } 1000} 1001 1002func validateOpAcceptHandshakeInput(v *AcceptHandshakeInput) error { 1003 if v == nil { 1004 return nil 1005 } 1006 invalidParams := smithy.InvalidParamsError{Context: "AcceptHandshakeInput"} 1007 if v.HandshakeId == nil { 1008 invalidParams.Add(smithy.NewErrParamRequired("HandshakeId")) 1009 } 1010 if invalidParams.Len() > 0 { 1011 return invalidParams 1012 } else { 1013 return nil 1014 } 1015} 1016 1017func validateOpAttachPolicyInput(v *AttachPolicyInput) error { 1018 if v == nil { 1019 return nil 1020 } 1021 invalidParams := smithy.InvalidParamsError{Context: "AttachPolicyInput"} 1022 if v.PolicyId == nil { 1023 invalidParams.Add(smithy.NewErrParamRequired("PolicyId")) 1024 } 1025 if v.TargetId == nil { 1026 invalidParams.Add(smithy.NewErrParamRequired("TargetId")) 1027 } 1028 if invalidParams.Len() > 0 { 1029 return invalidParams 1030 } else { 1031 return nil 1032 } 1033} 1034 1035func validateOpCancelHandshakeInput(v *CancelHandshakeInput) error { 1036 if v == nil { 1037 return nil 1038 } 1039 invalidParams := smithy.InvalidParamsError{Context: "CancelHandshakeInput"} 1040 if v.HandshakeId == nil { 1041 invalidParams.Add(smithy.NewErrParamRequired("HandshakeId")) 1042 } 1043 if invalidParams.Len() > 0 { 1044 return invalidParams 1045 } else { 1046 return nil 1047 } 1048} 1049 1050func validateOpCreateAccountInput(v *CreateAccountInput) error { 1051 if v == nil { 1052 return nil 1053 } 1054 invalidParams := smithy.InvalidParamsError{Context: "CreateAccountInput"} 1055 if v.Email == nil { 1056 invalidParams.Add(smithy.NewErrParamRequired("Email")) 1057 } 1058 if v.AccountName == nil { 1059 invalidParams.Add(smithy.NewErrParamRequired("AccountName")) 1060 } 1061 if v.Tags != nil { 1062 if err := validateTags(v.Tags); err != nil { 1063 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1064 } 1065 } 1066 if invalidParams.Len() > 0 { 1067 return invalidParams 1068 } else { 1069 return nil 1070 } 1071} 1072 1073func validateOpCreateGovCloudAccountInput(v *CreateGovCloudAccountInput) error { 1074 if v == nil { 1075 return nil 1076 } 1077 invalidParams := smithy.InvalidParamsError{Context: "CreateGovCloudAccountInput"} 1078 if v.Email == nil { 1079 invalidParams.Add(smithy.NewErrParamRequired("Email")) 1080 } 1081 if v.AccountName == nil { 1082 invalidParams.Add(smithy.NewErrParamRequired("AccountName")) 1083 } 1084 if v.Tags != nil { 1085 if err := validateTags(v.Tags); err != nil { 1086 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1087 } 1088 } 1089 if invalidParams.Len() > 0 { 1090 return invalidParams 1091 } else { 1092 return nil 1093 } 1094} 1095 1096func validateOpCreateOrganizationalUnitInput(v *CreateOrganizationalUnitInput) error { 1097 if v == nil { 1098 return nil 1099 } 1100 invalidParams := smithy.InvalidParamsError{Context: "CreateOrganizationalUnitInput"} 1101 if v.ParentId == nil { 1102 invalidParams.Add(smithy.NewErrParamRequired("ParentId")) 1103 } 1104 if v.Name == nil { 1105 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1106 } 1107 if v.Tags != nil { 1108 if err := validateTags(v.Tags); err != nil { 1109 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1110 } 1111 } 1112 if invalidParams.Len() > 0 { 1113 return invalidParams 1114 } else { 1115 return nil 1116 } 1117} 1118 1119func validateOpCreatePolicyInput(v *CreatePolicyInput) error { 1120 if v == nil { 1121 return nil 1122 } 1123 invalidParams := smithy.InvalidParamsError{Context: "CreatePolicyInput"} 1124 if v.Content == nil { 1125 invalidParams.Add(smithy.NewErrParamRequired("Content")) 1126 } 1127 if v.Description == nil { 1128 invalidParams.Add(smithy.NewErrParamRequired("Description")) 1129 } 1130 if v.Name == nil { 1131 invalidParams.Add(smithy.NewErrParamRequired("Name")) 1132 } 1133 if len(v.Type) == 0 { 1134 invalidParams.Add(smithy.NewErrParamRequired("Type")) 1135 } 1136 if v.Tags != nil { 1137 if err := validateTags(v.Tags); err != nil { 1138 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1139 } 1140 } 1141 if invalidParams.Len() > 0 { 1142 return invalidParams 1143 } else { 1144 return nil 1145 } 1146} 1147 1148func validateOpDeclineHandshakeInput(v *DeclineHandshakeInput) error { 1149 if v == nil { 1150 return nil 1151 } 1152 invalidParams := smithy.InvalidParamsError{Context: "DeclineHandshakeInput"} 1153 if v.HandshakeId == nil { 1154 invalidParams.Add(smithy.NewErrParamRequired("HandshakeId")) 1155 } 1156 if invalidParams.Len() > 0 { 1157 return invalidParams 1158 } else { 1159 return nil 1160 } 1161} 1162 1163func validateOpDeleteOrganizationalUnitInput(v *DeleteOrganizationalUnitInput) error { 1164 if v == nil { 1165 return nil 1166 } 1167 invalidParams := smithy.InvalidParamsError{Context: "DeleteOrganizationalUnitInput"} 1168 if v.OrganizationalUnitId == nil { 1169 invalidParams.Add(smithy.NewErrParamRequired("OrganizationalUnitId")) 1170 } 1171 if invalidParams.Len() > 0 { 1172 return invalidParams 1173 } else { 1174 return nil 1175 } 1176} 1177 1178func validateOpDeletePolicyInput(v *DeletePolicyInput) error { 1179 if v == nil { 1180 return nil 1181 } 1182 invalidParams := smithy.InvalidParamsError{Context: "DeletePolicyInput"} 1183 if v.PolicyId == nil { 1184 invalidParams.Add(smithy.NewErrParamRequired("PolicyId")) 1185 } 1186 if invalidParams.Len() > 0 { 1187 return invalidParams 1188 } else { 1189 return nil 1190 } 1191} 1192 1193func validateOpDeregisterDelegatedAdministratorInput(v *DeregisterDelegatedAdministratorInput) error { 1194 if v == nil { 1195 return nil 1196 } 1197 invalidParams := smithy.InvalidParamsError{Context: "DeregisterDelegatedAdministratorInput"} 1198 if v.AccountId == nil { 1199 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1200 } 1201 if v.ServicePrincipal == nil { 1202 invalidParams.Add(smithy.NewErrParamRequired("ServicePrincipal")) 1203 } 1204 if invalidParams.Len() > 0 { 1205 return invalidParams 1206 } else { 1207 return nil 1208 } 1209} 1210 1211func validateOpDescribeAccountInput(v *DescribeAccountInput) error { 1212 if v == nil { 1213 return nil 1214 } 1215 invalidParams := smithy.InvalidParamsError{Context: "DescribeAccountInput"} 1216 if v.AccountId == nil { 1217 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1218 } 1219 if invalidParams.Len() > 0 { 1220 return invalidParams 1221 } else { 1222 return nil 1223 } 1224} 1225 1226func validateOpDescribeCreateAccountStatusInput(v *DescribeCreateAccountStatusInput) error { 1227 if v == nil { 1228 return nil 1229 } 1230 invalidParams := smithy.InvalidParamsError{Context: "DescribeCreateAccountStatusInput"} 1231 if v.CreateAccountRequestId == nil { 1232 invalidParams.Add(smithy.NewErrParamRequired("CreateAccountRequestId")) 1233 } 1234 if invalidParams.Len() > 0 { 1235 return invalidParams 1236 } else { 1237 return nil 1238 } 1239} 1240 1241func validateOpDescribeEffectivePolicyInput(v *DescribeEffectivePolicyInput) error { 1242 if v == nil { 1243 return nil 1244 } 1245 invalidParams := smithy.InvalidParamsError{Context: "DescribeEffectivePolicyInput"} 1246 if len(v.PolicyType) == 0 { 1247 invalidParams.Add(smithy.NewErrParamRequired("PolicyType")) 1248 } 1249 if invalidParams.Len() > 0 { 1250 return invalidParams 1251 } else { 1252 return nil 1253 } 1254} 1255 1256func validateOpDescribeHandshakeInput(v *DescribeHandshakeInput) error { 1257 if v == nil { 1258 return nil 1259 } 1260 invalidParams := smithy.InvalidParamsError{Context: "DescribeHandshakeInput"} 1261 if v.HandshakeId == nil { 1262 invalidParams.Add(smithy.NewErrParamRequired("HandshakeId")) 1263 } 1264 if invalidParams.Len() > 0 { 1265 return invalidParams 1266 } else { 1267 return nil 1268 } 1269} 1270 1271func validateOpDescribeOrganizationalUnitInput(v *DescribeOrganizationalUnitInput) error { 1272 if v == nil { 1273 return nil 1274 } 1275 invalidParams := smithy.InvalidParamsError{Context: "DescribeOrganizationalUnitInput"} 1276 if v.OrganizationalUnitId == nil { 1277 invalidParams.Add(smithy.NewErrParamRequired("OrganizationalUnitId")) 1278 } 1279 if invalidParams.Len() > 0 { 1280 return invalidParams 1281 } else { 1282 return nil 1283 } 1284} 1285 1286func validateOpDescribePolicyInput(v *DescribePolicyInput) error { 1287 if v == nil { 1288 return nil 1289 } 1290 invalidParams := smithy.InvalidParamsError{Context: "DescribePolicyInput"} 1291 if v.PolicyId == nil { 1292 invalidParams.Add(smithy.NewErrParamRequired("PolicyId")) 1293 } 1294 if invalidParams.Len() > 0 { 1295 return invalidParams 1296 } else { 1297 return nil 1298 } 1299} 1300 1301func validateOpDetachPolicyInput(v *DetachPolicyInput) error { 1302 if v == nil { 1303 return nil 1304 } 1305 invalidParams := smithy.InvalidParamsError{Context: "DetachPolicyInput"} 1306 if v.PolicyId == nil { 1307 invalidParams.Add(smithy.NewErrParamRequired("PolicyId")) 1308 } 1309 if v.TargetId == nil { 1310 invalidParams.Add(smithy.NewErrParamRequired("TargetId")) 1311 } 1312 if invalidParams.Len() > 0 { 1313 return invalidParams 1314 } else { 1315 return nil 1316 } 1317} 1318 1319func validateOpDisableAWSServiceAccessInput(v *DisableAWSServiceAccessInput) error { 1320 if v == nil { 1321 return nil 1322 } 1323 invalidParams := smithy.InvalidParamsError{Context: "DisableAWSServiceAccessInput"} 1324 if v.ServicePrincipal == nil { 1325 invalidParams.Add(smithy.NewErrParamRequired("ServicePrincipal")) 1326 } 1327 if invalidParams.Len() > 0 { 1328 return invalidParams 1329 } else { 1330 return nil 1331 } 1332} 1333 1334func validateOpDisablePolicyTypeInput(v *DisablePolicyTypeInput) error { 1335 if v == nil { 1336 return nil 1337 } 1338 invalidParams := smithy.InvalidParamsError{Context: "DisablePolicyTypeInput"} 1339 if v.RootId == nil { 1340 invalidParams.Add(smithy.NewErrParamRequired("RootId")) 1341 } 1342 if len(v.PolicyType) == 0 { 1343 invalidParams.Add(smithy.NewErrParamRequired("PolicyType")) 1344 } 1345 if invalidParams.Len() > 0 { 1346 return invalidParams 1347 } else { 1348 return nil 1349 } 1350} 1351 1352func validateOpEnableAWSServiceAccessInput(v *EnableAWSServiceAccessInput) error { 1353 if v == nil { 1354 return nil 1355 } 1356 invalidParams := smithy.InvalidParamsError{Context: "EnableAWSServiceAccessInput"} 1357 if v.ServicePrincipal == nil { 1358 invalidParams.Add(smithy.NewErrParamRequired("ServicePrincipal")) 1359 } 1360 if invalidParams.Len() > 0 { 1361 return invalidParams 1362 } else { 1363 return nil 1364 } 1365} 1366 1367func validateOpEnablePolicyTypeInput(v *EnablePolicyTypeInput) error { 1368 if v == nil { 1369 return nil 1370 } 1371 invalidParams := smithy.InvalidParamsError{Context: "EnablePolicyTypeInput"} 1372 if v.RootId == nil { 1373 invalidParams.Add(smithy.NewErrParamRequired("RootId")) 1374 } 1375 if len(v.PolicyType) == 0 { 1376 invalidParams.Add(smithy.NewErrParamRequired("PolicyType")) 1377 } 1378 if invalidParams.Len() > 0 { 1379 return invalidParams 1380 } else { 1381 return nil 1382 } 1383} 1384 1385func validateOpInviteAccountToOrganizationInput(v *InviteAccountToOrganizationInput) error { 1386 if v == nil { 1387 return nil 1388 } 1389 invalidParams := smithy.InvalidParamsError{Context: "InviteAccountToOrganizationInput"} 1390 if v.Target == nil { 1391 invalidParams.Add(smithy.NewErrParamRequired("Target")) 1392 } else if v.Target != nil { 1393 if err := validateHandshakeParty(v.Target); err != nil { 1394 invalidParams.AddNested("Target", err.(smithy.InvalidParamsError)) 1395 } 1396 } 1397 if v.Tags != nil { 1398 if err := validateTags(v.Tags); err != nil { 1399 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1400 } 1401 } 1402 if invalidParams.Len() > 0 { 1403 return invalidParams 1404 } else { 1405 return nil 1406 } 1407} 1408 1409func validateOpListAccountsForParentInput(v *ListAccountsForParentInput) error { 1410 if v == nil { 1411 return nil 1412 } 1413 invalidParams := smithy.InvalidParamsError{Context: "ListAccountsForParentInput"} 1414 if v.ParentId == nil { 1415 invalidParams.Add(smithy.NewErrParamRequired("ParentId")) 1416 } 1417 if invalidParams.Len() > 0 { 1418 return invalidParams 1419 } else { 1420 return nil 1421 } 1422} 1423 1424func validateOpListChildrenInput(v *ListChildrenInput) error { 1425 if v == nil { 1426 return nil 1427 } 1428 invalidParams := smithy.InvalidParamsError{Context: "ListChildrenInput"} 1429 if v.ParentId == nil { 1430 invalidParams.Add(smithy.NewErrParamRequired("ParentId")) 1431 } 1432 if len(v.ChildType) == 0 { 1433 invalidParams.Add(smithy.NewErrParamRequired("ChildType")) 1434 } 1435 if invalidParams.Len() > 0 { 1436 return invalidParams 1437 } else { 1438 return nil 1439 } 1440} 1441 1442func validateOpListDelegatedServicesForAccountInput(v *ListDelegatedServicesForAccountInput) error { 1443 if v == nil { 1444 return nil 1445 } 1446 invalidParams := smithy.InvalidParamsError{Context: "ListDelegatedServicesForAccountInput"} 1447 if v.AccountId == nil { 1448 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1449 } 1450 if invalidParams.Len() > 0 { 1451 return invalidParams 1452 } else { 1453 return nil 1454 } 1455} 1456 1457func validateOpListOrganizationalUnitsForParentInput(v *ListOrganizationalUnitsForParentInput) error { 1458 if v == nil { 1459 return nil 1460 } 1461 invalidParams := smithy.InvalidParamsError{Context: "ListOrganizationalUnitsForParentInput"} 1462 if v.ParentId == nil { 1463 invalidParams.Add(smithy.NewErrParamRequired("ParentId")) 1464 } 1465 if invalidParams.Len() > 0 { 1466 return invalidParams 1467 } else { 1468 return nil 1469 } 1470} 1471 1472func validateOpListParentsInput(v *ListParentsInput) error { 1473 if v == nil { 1474 return nil 1475 } 1476 invalidParams := smithy.InvalidParamsError{Context: "ListParentsInput"} 1477 if v.ChildId == nil { 1478 invalidParams.Add(smithy.NewErrParamRequired("ChildId")) 1479 } 1480 if invalidParams.Len() > 0 { 1481 return invalidParams 1482 } else { 1483 return nil 1484 } 1485} 1486 1487func validateOpListPoliciesForTargetInput(v *ListPoliciesForTargetInput) error { 1488 if v == nil { 1489 return nil 1490 } 1491 invalidParams := smithy.InvalidParamsError{Context: "ListPoliciesForTargetInput"} 1492 if v.TargetId == nil { 1493 invalidParams.Add(smithy.NewErrParamRequired("TargetId")) 1494 } 1495 if len(v.Filter) == 0 { 1496 invalidParams.Add(smithy.NewErrParamRequired("Filter")) 1497 } 1498 if invalidParams.Len() > 0 { 1499 return invalidParams 1500 } else { 1501 return nil 1502 } 1503} 1504 1505func validateOpListPoliciesInput(v *ListPoliciesInput) error { 1506 if v == nil { 1507 return nil 1508 } 1509 invalidParams := smithy.InvalidParamsError{Context: "ListPoliciesInput"} 1510 if len(v.Filter) == 0 { 1511 invalidParams.Add(smithy.NewErrParamRequired("Filter")) 1512 } 1513 if invalidParams.Len() > 0 { 1514 return invalidParams 1515 } else { 1516 return nil 1517 } 1518} 1519 1520func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 1521 if v == nil { 1522 return nil 1523 } 1524 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 1525 if v.ResourceId == nil { 1526 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 1527 } 1528 if invalidParams.Len() > 0 { 1529 return invalidParams 1530 } else { 1531 return nil 1532 } 1533} 1534 1535func validateOpListTargetsForPolicyInput(v *ListTargetsForPolicyInput) error { 1536 if v == nil { 1537 return nil 1538 } 1539 invalidParams := smithy.InvalidParamsError{Context: "ListTargetsForPolicyInput"} 1540 if v.PolicyId == nil { 1541 invalidParams.Add(smithy.NewErrParamRequired("PolicyId")) 1542 } 1543 if invalidParams.Len() > 0 { 1544 return invalidParams 1545 } else { 1546 return nil 1547 } 1548} 1549 1550func validateOpMoveAccountInput(v *MoveAccountInput) error { 1551 if v == nil { 1552 return nil 1553 } 1554 invalidParams := smithy.InvalidParamsError{Context: "MoveAccountInput"} 1555 if v.AccountId == nil { 1556 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1557 } 1558 if v.SourceParentId == nil { 1559 invalidParams.Add(smithy.NewErrParamRequired("SourceParentId")) 1560 } 1561 if v.DestinationParentId == nil { 1562 invalidParams.Add(smithy.NewErrParamRequired("DestinationParentId")) 1563 } 1564 if invalidParams.Len() > 0 { 1565 return invalidParams 1566 } else { 1567 return nil 1568 } 1569} 1570 1571func validateOpRegisterDelegatedAdministratorInput(v *RegisterDelegatedAdministratorInput) error { 1572 if v == nil { 1573 return nil 1574 } 1575 invalidParams := smithy.InvalidParamsError{Context: "RegisterDelegatedAdministratorInput"} 1576 if v.AccountId == nil { 1577 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1578 } 1579 if v.ServicePrincipal == nil { 1580 invalidParams.Add(smithy.NewErrParamRequired("ServicePrincipal")) 1581 } 1582 if invalidParams.Len() > 0 { 1583 return invalidParams 1584 } else { 1585 return nil 1586 } 1587} 1588 1589func validateOpRemoveAccountFromOrganizationInput(v *RemoveAccountFromOrganizationInput) error { 1590 if v == nil { 1591 return nil 1592 } 1593 invalidParams := smithy.InvalidParamsError{Context: "RemoveAccountFromOrganizationInput"} 1594 if v.AccountId == nil { 1595 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1596 } 1597 if invalidParams.Len() > 0 { 1598 return invalidParams 1599 } else { 1600 return nil 1601 } 1602} 1603 1604func validateOpTagResourceInput(v *TagResourceInput) error { 1605 if v == nil { 1606 return nil 1607 } 1608 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 1609 if v.ResourceId == nil { 1610 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 1611 } 1612 if v.Tags == nil { 1613 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 1614 } else if v.Tags != nil { 1615 if err := validateTags(v.Tags); err != nil { 1616 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 1617 } 1618 } 1619 if invalidParams.Len() > 0 { 1620 return invalidParams 1621 } else { 1622 return nil 1623 } 1624} 1625 1626func validateOpUntagResourceInput(v *UntagResourceInput) error { 1627 if v == nil { 1628 return nil 1629 } 1630 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 1631 if v.ResourceId == nil { 1632 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 1633 } 1634 if v.TagKeys == nil { 1635 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 1636 } 1637 if invalidParams.Len() > 0 { 1638 return invalidParams 1639 } else { 1640 return nil 1641 } 1642} 1643 1644func validateOpUpdateOrganizationalUnitInput(v *UpdateOrganizationalUnitInput) error { 1645 if v == nil { 1646 return nil 1647 } 1648 invalidParams := smithy.InvalidParamsError{Context: "UpdateOrganizationalUnitInput"} 1649 if v.OrganizationalUnitId == nil { 1650 invalidParams.Add(smithy.NewErrParamRequired("OrganizationalUnitId")) 1651 } 1652 if invalidParams.Len() > 0 { 1653 return invalidParams 1654 } else { 1655 return nil 1656 } 1657} 1658 1659func validateOpUpdatePolicyInput(v *UpdatePolicyInput) error { 1660 if v == nil { 1661 return nil 1662 } 1663 invalidParams := smithy.InvalidParamsError{Context: "UpdatePolicyInput"} 1664 if v.PolicyId == nil { 1665 invalidParams.Add(smithy.NewErrParamRequired("PolicyId")) 1666 } 1667 if invalidParams.Len() > 0 { 1668 return invalidParams 1669 } else { 1670 return nil 1671 } 1672} 1673