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