1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package configservice 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/configservice/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpBatchGetAggregateResourceConfig struct { 14} 15 16func (*validateOpBatchGetAggregateResourceConfig) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpBatchGetAggregateResourceConfig) 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.(*BatchGetAggregateResourceConfigInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpBatchGetAggregateResourceConfigInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpBatchGetResourceConfig struct { 34} 35 36func (*validateOpBatchGetResourceConfig) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpBatchGetResourceConfig) 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.(*BatchGetResourceConfigInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpBatchGetResourceConfigInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpDeleteAggregationAuthorization struct { 54} 55 56func (*validateOpDeleteAggregationAuthorization) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpDeleteAggregationAuthorization) 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.(*DeleteAggregationAuthorizationInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpDeleteAggregationAuthorizationInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpDeleteConfigRule struct { 74} 75 76func (*validateOpDeleteConfigRule) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpDeleteConfigRule) 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.(*DeleteConfigRuleInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpDeleteConfigRuleInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpDeleteConfigurationAggregator struct { 94} 95 96func (*validateOpDeleteConfigurationAggregator) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpDeleteConfigurationAggregator) 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.(*DeleteConfigurationAggregatorInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpDeleteConfigurationAggregatorInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpDeleteConfigurationRecorder struct { 114} 115 116func (*validateOpDeleteConfigurationRecorder) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpDeleteConfigurationRecorder) 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.(*DeleteConfigurationRecorderInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpDeleteConfigurationRecorderInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDeleteConformancePack struct { 134} 135 136func (*validateOpDeleteConformancePack) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDeleteConformancePack) 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.(*DeleteConformancePackInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDeleteConformancePackInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeleteDeliveryChannel struct { 154} 155 156func (*validateOpDeleteDeliveryChannel) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeleteDeliveryChannel) 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.(*DeleteDeliveryChannelInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeleteDeliveryChannelInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDeleteEvaluationResults struct { 174} 175 176func (*validateOpDeleteEvaluationResults) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDeleteEvaluationResults) 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.(*DeleteEvaluationResultsInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDeleteEvaluationResultsInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDeleteOrganizationConfigRule struct { 194} 195 196func (*validateOpDeleteOrganizationConfigRule) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDeleteOrganizationConfigRule) 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.(*DeleteOrganizationConfigRuleInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDeleteOrganizationConfigRuleInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDeleteOrganizationConformancePack struct { 214} 215 216func (*validateOpDeleteOrganizationConformancePack) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDeleteOrganizationConformancePack) 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.(*DeleteOrganizationConformancePackInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDeleteOrganizationConformancePackInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDeletePendingAggregationRequest struct { 234} 235 236func (*validateOpDeletePendingAggregationRequest) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDeletePendingAggregationRequest) 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.(*DeletePendingAggregationRequestInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDeletePendingAggregationRequestInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDeleteRemediationConfiguration struct { 254} 255 256func (*validateOpDeleteRemediationConfiguration) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDeleteRemediationConfiguration) 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.(*DeleteRemediationConfigurationInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDeleteRemediationConfigurationInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDeleteRemediationExceptions struct { 274} 275 276func (*validateOpDeleteRemediationExceptions) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDeleteRemediationExceptions) 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.(*DeleteRemediationExceptionsInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDeleteRemediationExceptionsInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpDeleteResourceConfig struct { 294} 295 296func (*validateOpDeleteResourceConfig) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpDeleteResourceConfig) 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.(*DeleteResourceConfigInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpDeleteResourceConfigInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpDeleteRetentionConfiguration struct { 314} 315 316func (*validateOpDeleteRetentionConfiguration) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpDeleteRetentionConfiguration) 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.(*DeleteRetentionConfigurationInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpDeleteRetentionConfigurationInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpDeliverConfigSnapshot struct { 334} 335 336func (*validateOpDeliverConfigSnapshot) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpDeliverConfigSnapshot) 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.(*DeliverConfigSnapshotInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpDeliverConfigSnapshotInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpDescribeAggregateComplianceByConfigRules struct { 354} 355 356func (*validateOpDescribeAggregateComplianceByConfigRules) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpDescribeAggregateComplianceByConfigRules) 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.(*DescribeAggregateComplianceByConfigRulesInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpDescribeAggregateComplianceByConfigRulesInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpDescribeConfigurationAggregatorSourcesStatus struct { 374} 375 376func (*validateOpDescribeConfigurationAggregatorSourcesStatus) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpDescribeConfigurationAggregatorSourcesStatus) 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.(*DescribeConfigurationAggregatorSourcesStatusInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpDescribeConfigurationAggregatorSourcesStatusInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpDescribeConformancePackCompliance struct { 394} 395 396func (*validateOpDescribeConformancePackCompliance) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpDescribeConformancePackCompliance) 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.(*DescribeConformancePackComplianceInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpDescribeConformancePackComplianceInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpDescribeRemediationConfigurations struct { 414} 415 416func (*validateOpDescribeRemediationConfigurations) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpDescribeRemediationConfigurations) 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.(*DescribeRemediationConfigurationsInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpDescribeRemediationConfigurationsInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpDescribeRemediationExceptions struct { 434} 435 436func (*validateOpDescribeRemediationExceptions) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpDescribeRemediationExceptions) 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.(*DescribeRemediationExceptionsInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpDescribeRemediationExceptionsInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpDescribeRemediationExecutionStatus struct { 454} 455 456func (*validateOpDescribeRemediationExecutionStatus) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpDescribeRemediationExecutionStatus) 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.(*DescribeRemediationExecutionStatusInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpDescribeRemediationExecutionStatusInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpGetAggregateComplianceDetailsByConfigRule struct { 474} 475 476func (*validateOpGetAggregateComplianceDetailsByConfigRule) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpGetAggregateComplianceDetailsByConfigRule) 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.(*GetAggregateComplianceDetailsByConfigRuleInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpGetAggregateComplianceDetailsByConfigRuleInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpGetAggregateConfigRuleComplianceSummary struct { 494} 495 496func (*validateOpGetAggregateConfigRuleComplianceSummary) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpGetAggregateConfigRuleComplianceSummary) 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.(*GetAggregateConfigRuleComplianceSummaryInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpGetAggregateConfigRuleComplianceSummaryInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpGetAggregateDiscoveredResourceCounts struct { 514} 515 516func (*validateOpGetAggregateDiscoveredResourceCounts) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpGetAggregateDiscoveredResourceCounts) 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.(*GetAggregateDiscoveredResourceCountsInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpGetAggregateDiscoveredResourceCountsInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpGetAggregateResourceConfig struct { 534} 535 536func (*validateOpGetAggregateResourceConfig) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpGetAggregateResourceConfig) 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.(*GetAggregateResourceConfigInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpGetAggregateResourceConfigInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpGetComplianceDetailsByConfigRule struct { 554} 555 556func (*validateOpGetComplianceDetailsByConfigRule) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpGetComplianceDetailsByConfigRule) 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.(*GetComplianceDetailsByConfigRuleInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpGetComplianceDetailsByConfigRuleInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpGetComplianceDetailsByResource struct { 574} 575 576func (*validateOpGetComplianceDetailsByResource) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpGetComplianceDetailsByResource) 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.(*GetComplianceDetailsByResourceInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpGetComplianceDetailsByResourceInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpGetConformancePackComplianceDetails struct { 594} 595 596func (*validateOpGetConformancePackComplianceDetails) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpGetConformancePackComplianceDetails) 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.(*GetConformancePackComplianceDetailsInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpGetConformancePackComplianceDetailsInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpGetConformancePackComplianceSummary struct { 614} 615 616func (*validateOpGetConformancePackComplianceSummary) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpGetConformancePackComplianceSummary) 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.(*GetConformancePackComplianceSummaryInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpGetConformancePackComplianceSummaryInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpGetOrganizationConfigRuleDetailedStatus struct { 634} 635 636func (*validateOpGetOrganizationConfigRuleDetailedStatus) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpGetOrganizationConfigRuleDetailedStatus) 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.(*GetOrganizationConfigRuleDetailedStatusInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpGetOrganizationConfigRuleDetailedStatusInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpGetOrganizationConformancePackDetailedStatus struct { 654} 655 656func (*validateOpGetOrganizationConformancePackDetailedStatus) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpGetOrganizationConformancePackDetailedStatus) 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.(*GetOrganizationConformancePackDetailedStatusInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpGetOrganizationConformancePackDetailedStatusInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpGetResourceConfigHistory struct { 674} 675 676func (*validateOpGetResourceConfigHistory) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpGetResourceConfigHistory) 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.(*GetResourceConfigHistoryInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpGetResourceConfigHistoryInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpListAggregateDiscoveredResources struct { 694} 695 696func (*validateOpListAggregateDiscoveredResources) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpListAggregateDiscoveredResources) 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.(*ListAggregateDiscoveredResourcesInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpListAggregateDiscoveredResourcesInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpListDiscoveredResources struct { 714} 715 716func (*validateOpListDiscoveredResources) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpListDiscoveredResources) 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.(*ListDiscoveredResourcesInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpListDiscoveredResourcesInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpListTagsForResource struct { 734} 735 736func (*validateOpListTagsForResource) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpListTagsForResource) 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.(*ListTagsForResourceInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpListTagsForResourceInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753type validateOpPutAggregationAuthorization struct { 754} 755 756func (*validateOpPutAggregationAuthorization) ID() string { 757 return "OperationInputValidation" 758} 759 760func (m *validateOpPutAggregationAuthorization) 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.(*PutAggregationAuthorizationInput) 764 if !ok { 765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 766 } 767 if err := validateOpPutAggregationAuthorizationInput(input); err != nil { 768 return out, metadata, err 769 } 770 return next.HandleInitialize(ctx, in) 771} 772 773type validateOpPutConfigRule struct { 774} 775 776func (*validateOpPutConfigRule) ID() string { 777 return "OperationInputValidation" 778} 779 780func (m *validateOpPutConfigRule) 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.(*PutConfigRuleInput) 784 if !ok { 785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 786 } 787 if err := validateOpPutConfigRuleInput(input); err != nil { 788 return out, metadata, err 789 } 790 return next.HandleInitialize(ctx, in) 791} 792 793type validateOpPutConfigurationAggregator struct { 794} 795 796func (*validateOpPutConfigurationAggregator) ID() string { 797 return "OperationInputValidation" 798} 799 800func (m *validateOpPutConfigurationAggregator) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 801 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 802) { 803 input, ok := in.Parameters.(*PutConfigurationAggregatorInput) 804 if !ok { 805 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 806 } 807 if err := validateOpPutConfigurationAggregatorInput(input); err != nil { 808 return out, metadata, err 809 } 810 return next.HandleInitialize(ctx, in) 811} 812 813type validateOpPutConfigurationRecorder struct { 814} 815 816func (*validateOpPutConfigurationRecorder) ID() string { 817 return "OperationInputValidation" 818} 819 820func (m *validateOpPutConfigurationRecorder) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 821 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 822) { 823 input, ok := in.Parameters.(*PutConfigurationRecorderInput) 824 if !ok { 825 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 826 } 827 if err := validateOpPutConfigurationRecorderInput(input); err != nil { 828 return out, metadata, err 829 } 830 return next.HandleInitialize(ctx, in) 831} 832 833type validateOpPutConformancePack struct { 834} 835 836func (*validateOpPutConformancePack) ID() string { 837 return "OperationInputValidation" 838} 839 840func (m *validateOpPutConformancePack) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 841 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 842) { 843 input, ok := in.Parameters.(*PutConformancePackInput) 844 if !ok { 845 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 846 } 847 if err := validateOpPutConformancePackInput(input); err != nil { 848 return out, metadata, err 849 } 850 return next.HandleInitialize(ctx, in) 851} 852 853type validateOpPutDeliveryChannel struct { 854} 855 856func (*validateOpPutDeliveryChannel) ID() string { 857 return "OperationInputValidation" 858} 859 860func (m *validateOpPutDeliveryChannel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 861 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 862) { 863 input, ok := in.Parameters.(*PutDeliveryChannelInput) 864 if !ok { 865 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 866 } 867 if err := validateOpPutDeliveryChannelInput(input); err != nil { 868 return out, metadata, err 869 } 870 return next.HandleInitialize(ctx, in) 871} 872 873type validateOpPutEvaluations struct { 874} 875 876func (*validateOpPutEvaluations) ID() string { 877 return "OperationInputValidation" 878} 879 880func (m *validateOpPutEvaluations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 881 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 882) { 883 input, ok := in.Parameters.(*PutEvaluationsInput) 884 if !ok { 885 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 886 } 887 if err := validateOpPutEvaluationsInput(input); err != nil { 888 return out, metadata, err 889 } 890 return next.HandleInitialize(ctx, in) 891} 892 893type validateOpPutOrganizationConfigRule struct { 894} 895 896func (*validateOpPutOrganizationConfigRule) ID() string { 897 return "OperationInputValidation" 898} 899 900func (m *validateOpPutOrganizationConfigRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 901 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 902) { 903 input, ok := in.Parameters.(*PutOrganizationConfigRuleInput) 904 if !ok { 905 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 906 } 907 if err := validateOpPutOrganizationConfigRuleInput(input); err != nil { 908 return out, metadata, err 909 } 910 return next.HandleInitialize(ctx, in) 911} 912 913type validateOpPutOrganizationConformancePack struct { 914} 915 916func (*validateOpPutOrganizationConformancePack) ID() string { 917 return "OperationInputValidation" 918} 919 920func (m *validateOpPutOrganizationConformancePack) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 921 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 922) { 923 input, ok := in.Parameters.(*PutOrganizationConformancePackInput) 924 if !ok { 925 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 926 } 927 if err := validateOpPutOrganizationConformancePackInput(input); err != nil { 928 return out, metadata, err 929 } 930 return next.HandleInitialize(ctx, in) 931} 932 933type validateOpPutRemediationConfigurations struct { 934} 935 936func (*validateOpPutRemediationConfigurations) ID() string { 937 return "OperationInputValidation" 938} 939 940func (m *validateOpPutRemediationConfigurations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 941 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 942) { 943 input, ok := in.Parameters.(*PutRemediationConfigurationsInput) 944 if !ok { 945 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 946 } 947 if err := validateOpPutRemediationConfigurationsInput(input); err != nil { 948 return out, metadata, err 949 } 950 return next.HandleInitialize(ctx, in) 951} 952 953type validateOpPutRemediationExceptions struct { 954} 955 956func (*validateOpPutRemediationExceptions) ID() string { 957 return "OperationInputValidation" 958} 959 960func (m *validateOpPutRemediationExceptions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 961 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 962) { 963 input, ok := in.Parameters.(*PutRemediationExceptionsInput) 964 if !ok { 965 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 966 } 967 if err := validateOpPutRemediationExceptionsInput(input); err != nil { 968 return out, metadata, err 969 } 970 return next.HandleInitialize(ctx, in) 971} 972 973type validateOpPutResourceConfig struct { 974} 975 976func (*validateOpPutResourceConfig) ID() string { 977 return "OperationInputValidation" 978} 979 980func (m *validateOpPutResourceConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 981 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 982) { 983 input, ok := in.Parameters.(*PutResourceConfigInput) 984 if !ok { 985 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 986 } 987 if err := validateOpPutResourceConfigInput(input); err != nil { 988 return out, metadata, err 989 } 990 return next.HandleInitialize(ctx, in) 991} 992 993type validateOpPutRetentionConfiguration struct { 994} 995 996func (*validateOpPutRetentionConfiguration) ID() string { 997 return "OperationInputValidation" 998} 999 1000func (m *validateOpPutRetentionConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1001 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1002) { 1003 input, ok := in.Parameters.(*PutRetentionConfigurationInput) 1004 if !ok { 1005 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1006 } 1007 if err := validateOpPutRetentionConfigurationInput(input); err != nil { 1008 return out, metadata, err 1009 } 1010 return next.HandleInitialize(ctx, in) 1011} 1012 1013type validateOpSelectAggregateResourceConfig struct { 1014} 1015 1016func (*validateOpSelectAggregateResourceConfig) ID() string { 1017 return "OperationInputValidation" 1018} 1019 1020func (m *validateOpSelectAggregateResourceConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1021 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1022) { 1023 input, ok := in.Parameters.(*SelectAggregateResourceConfigInput) 1024 if !ok { 1025 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1026 } 1027 if err := validateOpSelectAggregateResourceConfigInput(input); err != nil { 1028 return out, metadata, err 1029 } 1030 return next.HandleInitialize(ctx, in) 1031} 1032 1033type validateOpSelectResourceConfig struct { 1034} 1035 1036func (*validateOpSelectResourceConfig) ID() string { 1037 return "OperationInputValidation" 1038} 1039 1040func (m *validateOpSelectResourceConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1041 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1042) { 1043 input, ok := in.Parameters.(*SelectResourceConfigInput) 1044 if !ok { 1045 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1046 } 1047 if err := validateOpSelectResourceConfigInput(input); err != nil { 1048 return out, metadata, err 1049 } 1050 return next.HandleInitialize(ctx, in) 1051} 1052 1053type validateOpStartConfigurationRecorder struct { 1054} 1055 1056func (*validateOpStartConfigurationRecorder) ID() string { 1057 return "OperationInputValidation" 1058} 1059 1060func (m *validateOpStartConfigurationRecorder) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1061 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1062) { 1063 input, ok := in.Parameters.(*StartConfigurationRecorderInput) 1064 if !ok { 1065 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1066 } 1067 if err := validateOpStartConfigurationRecorderInput(input); err != nil { 1068 return out, metadata, err 1069 } 1070 return next.HandleInitialize(ctx, in) 1071} 1072 1073type validateOpStartRemediationExecution struct { 1074} 1075 1076func (*validateOpStartRemediationExecution) ID() string { 1077 return "OperationInputValidation" 1078} 1079 1080func (m *validateOpStartRemediationExecution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1081 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1082) { 1083 input, ok := in.Parameters.(*StartRemediationExecutionInput) 1084 if !ok { 1085 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1086 } 1087 if err := validateOpStartRemediationExecutionInput(input); err != nil { 1088 return out, metadata, err 1089 } 1090 return next.HandleInitialize(ctx, in) 1091} 1092 1093type validateOpStopConfigurationRecorder struct { 1094} 1095 1096func (*validateOpStopConfigurationRecorder) ID() string { 1097 return "OperationInputValidation" 1098} 1099 1100func (m *validateOpStopConfigurationRecorder) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1101 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1102) { 1103 input, ok := in.Parameters.(*StopConfigurationRecorderInput) 1104 if !ok { 1105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1106 } 1107 if err := validateOpStopConfigurationRecorderInput(input); err != nil { 1108 return out, metadata, err 1109 } 1110 return next.HandleInitialize(ctx, in) 1111} 1112 1113type validateOpTagResource struct { 1114} 1115 1116func (*validateOpTagResource) ID() string { 1117 return "OperationInputValidation" 1118} 1119 1120func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1121 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1122) { 1123 input, ok := in.Parameters.(*TagResourceInput) 1124 if !ok { 1125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1126 } 1127 if err := validateOpTagResourceInput(input); err != nil { 1128 return out, metadata, err 1129 } 1130 return next.HandleInitialize(ctx, in) 1131} 1132 1133type validateOpUntagResource struct { 1134} 1135 1136func (*validateOpUntagResource) ID() string { 1137 return "OperationInputValidation" 1138} 1139 1140func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1141 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1142) { 1143 input, ok := in.Parameters.(*UntagResourceInput) 1144 if !ok { 1145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1146 } 1147 if err := validateOpUntagResourceInput(input); err != nil { 1148 return out, metadata, err 1149 } 1150 return next.HandleInitialize(ctx, in) 1151} 1152 1153func addOpBatchGetAggregateResourceConfigValidationMiddleware(stack *middleware.Stack) error { 1154 return stack.Initialize.Add(&validateOpBatchGetAggregateResourceConfig{}, middleware.After) 1155} 1156 1157func addOpBatchGetResourceConfigValidationMiddleware(stack *middleware.Stack) error { 1158 return stack.Initialize.Add(&validateOpBatchGetResourceConfig{}, middleware.After) 1159} 1160 1161func addOpDeleteAggregationAuthorizationValidationMiddleware(stack *middleware.Stack) error { 1162 return stack.Initialize.Add(&validateOpDeleteAggregationAuthorization{}, middleware.After) 1163} 1164 1165func addOpDeleteConfigRuleValidationMiddleware(stack *middleware.Stack) error { 1166 return stack.Initialize.Add(&validateOpDeleteConfigRule{}, middleware.After) 1167} 1168 1169func addOpDeleteConfigurationAggregatorValidationMiddleware(stack *middleware.Stack) error { 1170 return stack.Initialize.Add(&validateOpDeleteConfigurationAggregator{}, middleware.After) 1171} 1172 1173func addOpDeleteConfigurationRecorderValidationMiddleware(stack *middleware.Stack) error { 1174 return stack.Initialize.Add(&validateOpDeleteConfigurationRecorder{}, middleware.After) 1175} 1176 1177func addOpDeleteConformancePackValidationMiddleware(stack *middleware.Stack) error { 1178 return stack.Initialize.Add(&validateOpDeleteConformancePack{}, middleware.After) 1179} 1180 1181func addOpDeleteDeliveryChannelValidationMiddleware(stack *middleware.Stack) error { 1182 return stack.Initialize.Add(&validateOpDeleteDeliveryChannel{}, middleware.After) 1183} 1184 1185func addOpDeleteEvaluationResultsValidationMiddleware(stack *middleware.Stack) error { 1186 return stack.Initialize.Add(&validateOpDeleteEvaluationResults{}, middleware.After) 1187} 1188 1189func addOpDeleteOrganizationConfigRuleValidationMiddleware(stack *middleware.Stack) error { 1190 return stack.Initialize.Add(&validateOpDeleteOrganizationConfigRule{}, middleware.After) 1191} 1192 1193func addOpDeleteOrganizationConformancePackValidationMiddleware(stack *middleware.Stack) error { 1194 return stack.Initialize.Add(&validateOpDeleteOrganizationConformancePack{}, middleware.After) 1195} 1196 1197func addOpDeletePendingAggregationRequestValidationMiddleware(stack *middleware.Stack) error { 1198 return stack.Initialize.Add(&validateOpDeletePendingAggregationRequest{}, middleware.After) 1199} 1200 1201func addOpDeleteRemediationConfigurationValidationMiddleware(stack *middleware.Stack) error { 1202 return stack.Initialize.Add(&validateOpDeleteRemediationConfiguration{}, middleware.After) 1203} 1204 1205func addOpDeleteRemediationExceptionsValidationMiddleware(stack *middleware.Stack) error { 1206 return stack.Initialize.Add(&validateOpDeleteRemediationExceptions{}, middleware.After) 1207} 1208 1209func addOpDeleteResourceConfigValidationMiddleware(stack *middleware.Stack) error { 1210 return stack.Initialize.Add(&validateOpDeleteResourceConfig{}, middleware.After) 1211} 1212 1213func addOpDeleteRetentionConfigurationValidationMiddleware(stack *middleware.Stack) error { 1214 return stack.Initialize.Add(&validateOpDeleteRetentionConfiguration{}, middleware.After) 1215} 1216 1217func addOpDeliverConfigSnapshotValidationMiddleware(stack *middleware.Stack) error { 1218 return stack.Initialize.Add(&validateOpDeliverConfigSnapshot{}, middleware.After) 1219} 1220 1221func addOpDescribeAggregateComplianceByConfigRulesValidationMiddleware(stack *middleware.Stack) error { 1222 return stack.Initialize.Add(&validateOpDescribeAggregateComplianceByConfigRules{}, middleware.After) 1223} 1224 1225func addOpDescribeConfigurationAggregatorSourcesStatusValidationMiddleware(stack *middleware.Stack) error { 1226 return stack.Initialize.Add(&validateOpDescribeConfigurationAggregatorSourcesStatus{}, middleware.After) 1227} 1228 1229func addOpDescribeConformancePackComplianceValidationMiddleware(stack *middleware.Stack) error { 1230 return stack.Initialize.Add(&validateOpDescribeConformancePackCompliance{}, middleware.After) 1231} 1232 1233func addOpDescribeRemediationConfigurationsValidationMiddleware(stack *middleware.Stack) error { 1234 return stack.Initialize.Add(&validateOpDescribeRemediationConfigurations{}, middleware.After) 1235} 1236 1237func addOpDescribeRemediationExceptionsValidationMiddleware(stack *middleware.Stack) error { 1238 return stack.Initialize.Add(&validateOpDescribeRemediationExceptions{}, middleware.After) 1239} 1240 1241func addOpDescribeRemediationExecutionStatusValidationMiddleware(stack *middleware.Stack) error { 1242 return stack.Initialize.Add(&validateOpDescribeRemediationExecutionStatus{}, middleware.After) 1243} 1244 1245func addOpGetAggregateComplianceDetailsByConfigRuleValidationMiddleware(stack *middleware.Stack) error { 1246 return stack.Initialize.Add(&validateOpGetAggregateComplianceDetailsByConfigRule{}, middleware.After) 1247} 1248 1249func addOpGetAggregateConfigRuleComplianceSummaryValidationMiddleware(stack *middleware.Stack) error { 1250 return stack.Initialize.Add(&validateOpGetAggregateConfigRuleComplianceSummary{}, middleware.After) 1251} 1252 1253func addOpGetAggregateDiscoveredResourceCountsValidationMiddleware(stack *middleware.Stack) error { 1254 return stack.Initialize.Add(&validateOpGetAggregateDiscoveredResourceCounts{}, middleware.After) 1255} 1256 1257func addOpGetAggregateResourceConfigValidationMiddleware(stack *middleware.Stack) error { 1258 return stack.Initialize.Add(&validateOpGetAggregateResourceConfig{}, middleware.After) 1259} 1260 1261func addOpGetComplianceDetailsByConfigRuleValidationMiddleware(stack *middleware.Stack) error { 1262 return stack.Initialize.Add(&validateOpGetComplianceDetailsByConfigRule{}, middleware.After) 1263} 1264 1265func addOpGetComplianceDetailsByResourceValidationMiddleware(stack *middleware.Stack) error { 1266 return stack.Initialize.Add(&validateOpGetComplianceDetailsByResource{}, middleware.After) 1267} 1268 1269func addOpGetConformancePackComplianceDetailsValidationMiddleware(stack *middleware.Stack) error { 1270 return stack.Initialize.Add(&validateOpGetConformancePackComplianceDetails{}, middleware.After) 1271} 1272 1273func addOpGetConformancePackComplianceSummaryValidationMiddleware(stack *middleware.Stack) error { 1274 return stack.Initialize.Add(&validateOpGetConformancePackComplianceSummary{}, middleware.After) 1275} 1276 1277func addOpGetOrganizationConfigRuleDetailedStatusValidationMiddleware(stack *middleware.Stack) error { 1278 return stack.Initialize.Add(&validateOpGetOrganizationConfigRuleDetailedStatus{}, middleware.After) 1279} 1280 1281func addOpGetOrganizationConformancePackDetailedStatusValidationMiddleware(stack *middleware.Stack) error { 1282 return stack.Initialize.Add(&validateOpGetOrganizationConformancePackDetailedStatus{}, middleware.After) 1283} 1284 1285func addOpGetResourceConfigHistoryValidationMiddleware(stack *middleware.Stack) error { 1286 return stack.Initialize.Add(&validateOpGetResourceConfigHistory{}, middleware.After) 1287} 1288 1289func addOpListAggregateDiscoveredResourcesValidationMiddleware(stack *middleware.Stack) error { 1290 return stack.Initialize.Add(&validateOpListAggregateDiscoveredResources{}, middleware.After) 1291} 1292 1293func addOpListDiscoveredResourcesValidationMiddleware(stack *middleware.Stack) error { 1294 return stack.Initialize.Add(&validateOpListDiscoveredResources{}, middleware.After) 1295} 1296 1297func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 1298 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 1299} 1300 1301func addOpPutAggregationAuthorizationValidationMiddleware(stack *middleware.Stack) error { 1302 return stack.Initialize.Add(&validateOpPutAggregationAuthorization{}, middleware.After) 1303} 1304 1305func addOpPutConfigRuleValidationMiddleware(stack *middleware.Stack) error { 1306 return stack.Initialize.Add(&validateOpPutConfigRule{}, middleware.After) 1307} 1308 1309func addOpPutConfigurationAggregatorValidationMiddleware(stack *middleware.Stack) error { 1310 return stack.Initialize.Add(&validateOpPutConfigurationAggregator{}, middleware.After) 1311} 1312 1313func addOpPutConfigurationRecorderValidationMiddleware(stack *middleware.Stack) error { 1314 return stack.Initialize.Add(&validateOpPutConfigurationRecorder{}, middleware.After) 1315} 1316 1317func addOpPutConformancePackValidationMiddleware(stack *middleware.Stack) error { 1318 return stack.Initialize.Add(&validateOpPutConformancePack{}, middleware.After) 1319} 1320 1321func addOpPutDeliveryChannelValidationMiddleware(stack *middleware.Stack) error { 1322 return stack.Initialize.Add(&validateOpPutDeliveryChannel{}, middleware.After) 1323} 1324 1325func addOpPutEvaluationsValidationMiddleware(stack *middleware.Stack) error { 1326 return stack.Initialize.Add(&validateOpPutEvaluations{}, middleware.After) 1327} 1328 1329func addOpPutOrganizationConfigRuleValidationMiddleware(stack *middleware.Stack) error { 1330 return stack.Initialize.Add(&validateOpPutOrganizationConfigRule{}, middleware.After) 1331} 1332 1333func addOpPutOrganizationConformancePackValidationMiddleware(stack *middleware.Stack) error { 1334 return stack.Initialize.Add(&validateOpPutOrganizationConformancePack{}, middleware.After) 1335} 1336 1337func addOpPutRemediationConfigurationsValidationMiddleware(stack *middleware.Stack) error { 1338 return stack.Initialize.Add(&validateOpPutRemediationConfigurations{}, middleware.After) 1339} 1340 1341func addOpPutRemediationExceptionsValidationMiddleware(stack *middleware.Stack) error { 1342 return stack.Initialize.Add(&validateOpPutRemediationExceptions{}, middleware.After) 1343} 1344 1345func addOpPutResourceConfigValidationMiddleware(stack *middleware.Stack) error { 1346 return stack.Initialize.Add(&validateOpPutResourceConfig{}, middleware.After) 1347} 1348 1349func addOpPutRetentionConfigurationValidationMiddleware(stack *middleware.Stack) error { 1350 return stack.Initialize.Add(&validateOpPutRetentionConfiguration{}, middleware.After) 1351} 1352 1353func addOpSelectAggregateResourceConfigValidationMiddleware(stack *middleware.Stack) error { 1354 return stack.Initialize.Add(&validateOpSelectAggregateResourceConfig{}, middleware.After) 1355} 1356 1357func addOpSelectResourceConfigValidationMiddleware(stack *middleware.Stack) error { 1358 return stack.Initialize.Add(&validateOpSelectResourceConfig{}, middleware.After) 1359} 1360 1361func addOpStartConfigurationRecorderValidationMiddleware(stack *middleware.Stack) error { 1362 return stack.Initialize.Add(&validateOpStartConfigurationRecorder{}, middleware.After) 1363} 1364 1365func addOpStartRemediationExecutionValidationMiddleware(stack *middleware.Stack) error { 1366 return stack.Initialize.Add(&validateOpStartRemediationExecution{}, middleware.After) 1367} 1368 1369func addOpStopConfigurationRecorderValidationMiddleware(stack *middleware.Stack) error { 1370 return stack.Initialize.Add(&validateOpStopConfigurationRecorder{}, middleware.After) 1371} 1372 1373func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 1374 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 1375} 1376 1377func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 1378 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 1379} 1380 1381func validateAccountAggregationSource(v *types.AccountAggregationSource) error { 1382 if v == nil { 1383 return nil 1384 } 1385 invalidParams := smithy.InvalidParamsError{Context: "AccountAggregationSource"} 1386 if v.AccountIds == nil { 1387 invalidParams.Add(smithy.NewErrParamRequired("AccountIds")) 1388 } 1389 if invalidParams.Len() > 0 { 1390 return invalidParams 1391 } else { 1392 return nil 1393 } 1394} 1395 1396func validateAccountAggregationSourceList(v []types.AccountAggregationSource) error { 1397 if v == nil { 1398 return nil 1399 } 1400 invalidParams := smithy.InvalidParamsError{Context: "AccountAggregationSourceList"} 1401 for i := range v { 1402 if err := validateAccountAggregationSource(&v[i]); err != nil { 1403 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1404 } 1405 } 1406 if invalidParams.Len() > 0 { 1407 return invalidParams 1408 } else { 1409 return nil 1410 } 1411} 1412 1413func validateAggregateResourceIdentifier(v *types.AggregateResourceIdentifier) error { 1414 if v == nil { 1415 return nil 1416 } 1417 invalidParams := smithy.InvalidParamsError{Context: "AggregateResourceIdentifier"} 1418 if v.SourceAccountId == nil { 1419 invalidParams.Add(smithy.NewErrParamRequired("SourceAccountId")) 1420 } 1421 if v.SourceRegion == nil { 1422 invalidParams.Add(smithy.NewErrParamRequired("SourceRegion")) 1423 } 1424 if v.ResourceId == nil { 1425 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 1426 } 1427 if len(v.ResourceType) == 0 { 1428 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 1429 } 1430 if invalidParams.Len() > 0 { 1431 return invalidParams 1432 } else { 1433 return nil 1434 } 1435} 1436 1437func validateConfigRule(v *types.ConfigRule) error { 1438 if v == nil { 1439 return nil 1440 } 1441 invalidParams := smithy.InvalidParamsError{Context: "ConfigRule"} 1442 if v.Source == nil { 1443 invalidParams.Add(smithy.NewErrParamRequired("Source")) 1444 } else if v.Source != nil { 1445 if err := validateSource(v.Source); err != nil { 1446 invalidParams.AddNested("Source", err.(smithy.InvalidParamsError)) 1447 } 1448 } 1449 if invalidParams.Len() > 0 { 1450 return invalidParams 1451 } else { 1452 return nil 1453 } 1454} 1455 1456func validateConformancePackInputParameter(v *types.ConformancePackInputParameter) error { 1457 if v == nil { 1458 return nil 1459 } 1460 invalidParams := smithy.InvalidParamsError{Context: "ConformancePackInputParameter"} 1461 if v.ParameterName == nil { 1462 invalidParams.Add(smithy.NewErrParamRequired("ParameterName")) 1463 } 1464 if v.ParameterValue == nil { 1465 invalidParams.Add(smithy.NewErrParamRequired("ParameterValue")) 1466 } 1467 if invalidParams.Len() > 0 { 1468 return invalidParams 1469 } else { 1470 return nil 1471 } 1472} 1473 1474func validateConformancePackInputParameters(v []types.ConformancePackInputParameter) error { 1475 if v == nil { 1476 return nil 1477 } 1478 invalidParams := smithy.InvalidParamsError{Context: "ConformancePackInputParameters"} 1479 for i := range v { 1480 if err := validateConformancePackInputParameter(&v[i]); err != nil { 1481 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1482 } 1483 } 1484 if invalidParams.Len() > 0 { 1485 return invalidParams 1486 } else { 1487 return nil 1488 } 1489} 1490 1491func validateEvaluation(v *types.Evaluation) error { 1492 if v == nil { 1493 return nil 1494 } 1495 invalidParams := smithy.InvalidParamsError{Context: "Evaluation"} 1496 if v.ComplianceResourceType == nil { 1497 invalidParams.Add(smithy.NewErrParamRequired("ComplianceResourceType")) 1498 } 1499 if v.ComplianceResourceId == nil { 1500 invalidParams.Add(smithy.NewErrParamRequired("ComplianceResourceId")) 1501 } 1502 if len(v.ComplianceType) == 0 { 1503 invalidParams.Add(smithy.NewErrParamRequired("ComplianceType")) 1504 } 1505 if v.OrderingTimestamp == nil { 1506 invalidParams.Add(smithy.NewErrParamRequired("OrderingTimestamp")) 1507 } 1508 if invalidParams.Len() > 0 { 1509 return invalidParams 1510 } else { 1511 return nil 1512 } 1513} 1514 1515func validateEvaluations(v []types.Evaluation) error { 1516 if v == nil { 1517 return nil 1518 } 1519 invalidParams := smithy.InvalidParamsError{Context: "Evaluations"} 1520 for i := range v { 1521 if err := validateEvaluation(&v[i]); err != nil { 1522 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1523 } 1524 } 1525 if invalidParams.Len() > 0 { 1526 return invalidParams 1527 } else { 1528 return nil 1529 } 1530} 1531 1532func validateOrganizationAggregationSource(v *types.OrganizationAggregationSource) error { 1533 if v == nil { 1534 return nil 1535 } 1536 invalidParams := smithy.InvalidParamsError{Context: "OrganizationAggregationSource"} 1537 if v.RoleArn == nil { 1538 invalidParams.Add(smithy.NewErrParamRequired("RoleArn")) 1539 } 1540 if invalidParams.Len() > 0 { 1541 return invalidParams 1542 } else { 1543 return nil 1544 } 1545} 1546 1547func validateOrganizationCustomRuleMetadata(v *types.OrganizationCustomRuleMetadata) error { 1548 if v == nil { 1549 return nil 1550 } 1551 invalidParams := smithy.InvalidParamsError{Context: "OrganizationCustomRuleMetadata"} 1552 if v.LambdaFunctionArn == nil { 1553 invalidParams.Add(smithy.NewErrParamRequired("LambdaFunctionArn")) 1554 } 1555 if v.OrganizationConfigRuleTriggerTypes == nil { 1556 invalidParams.Add(smithy.NewErrParamRequired("OrganizationConfigRuleTriggerTypes")) 1557 } 1558 if invalidParams.Len() > 0 { 1559 return invalidParams 1560 } else { 1561 return nil 1562 } 1563} 1564 1565func validateOrganizationManagedRuleMetadata(v *types.OrganizationManagedRuleMetadata) error { 1566 if v == nil { 1567 return nil 1568 } 1569 invalidParams := smithy.InvalidParamsError{Context: "OrganizationManagedRuleMetadata"} 1570 if v.RuleIdentifier == nil { 1571 invalidParams.Add(smithy.NewErrParamRequired("RuleIdentifier")) 1572 } 1573 if invalidParams.Len() > 0 { 1574 return invalidParams 1575 } else { 1576 return nil 1577 } 1578} 1579 1580func validateRemediationConfiguration(v *types.RemediationConfiguration) error { 1581 if v == nil { 1582 return nil 1583 } 1584 invalidParams := smithy.InvalidParamsError{Context: "RemediationConfiguration"} 1585 if v.ConfigRuleName == nil { 1586 invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName")) 1587 } 1588 if len(v.TargetType) == 0 { 1589 invalidParams.Add(smithy.NewErrParamRequired("TargetType")) 1590 } 1591 if v.TargetId == nil { 1592 invalidParams.Add(smithy.NewErrParamRequired("TargetId")) 1593 } 1594 if v.Parameters != nil { 1595 if err := validateRemediationParameters(v.Parameters); err != nil { 1596 invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError)) 1597 } 1598 } 1599 if invalidParams.Len() > 0 { 1600 return invalidParams 1601 } else { 1602 return nil 1603 } 1604} 1605 1606func validateRemediationConfigurations(v []types.RemediationConfiguration) error { 1607 if v == nil { 1608 return nil 1609 } 1610 invalidParams := smithy.InvalidParamsError{Context: "RemediationConfigurations"} 1611 for i := range v { 1612 if err := validateRemediationConfiguration(&v[i]); err != nil { 1613 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1614 } 1615 } 1616 if invalidParams.Len() > 0 { 1617 return invalidParams 1618 } else { 1619 return nil 1620 } 1621} 1622 1623func validateRemediationParameters(v map[string]types.RemediationParameterValue) error { 1624 if v == nil { 1625 return nil 1626 } 1627 invalidParams := smithy.InvalidParamsError{Context: "RemediationParameters"} 1628 for key := range v { 1629 value := v[key] 1630 if err := validateRemediationParameterValue(&value); err != nil { 1631 invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError)) 1632 } 1633 } 1634 if invalidParams.Len() > 0 { 1635 return invalidParams 1636 } else { 1637 return nil 1638 } 1639} 1640 1641func validateRemediationParameterValue(v *types.RemediationParameterValue) error { 1642 if v == nil { 1643 return nil 1644 } 1645 invalidParams := smithy.InvalidParamsError{Context: "RemediationParameterValue"} 1646 if v.ResourceValue != nil { 1647 if err := validateResourceValue(v.ResourceValue); err != nil { 1648 invalidParams.AddNested("ResourceValue", err.(smithy.InvalidParamsError)) 1649 } 1650 } 1651 if v.StaticValue != nil { 1652 if err := validateStaticValue(v.StaticValue); err != nil { 1653 invalidParams.AddNested("StaticValue", err.(smithy.InvalidParamsError)) 1654 } 1655 } 1656 if invalidParams.Len() > 0 { 1657 return invalidParams 1658 } else { 1659 return nil 1660 } 1661} 1662 1663func validateResourceIdentifiersList(v []types.AggregateResourceIdentifier) error { 1664 if v == nil { 1665 return nil 1666 } 1667 invalidParams := smithy.InvalidParamsError{Context: "ResourceIdentifiersList"} 1668 for i := range v { 1669 if err := validateAggregateResourceIdentifier(&v[i]); err != nil { 1670 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1671 } 1672 } 1673 if invalidParams.Len() > 0 { 1674 return invalidParams 1675 } else { 1676 return nil 1677 } 1678} 1679 1680func validateResourceKey(v *types.ResourceKey) error { 1681 if v == nil { 1682 return nil 1683 } 1684 invalidParams := smithy.InvalidParamsError{Context: "ResourceKey"} 1685 if len(v.ResourceType) == 0 { 1686 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 1687 } 1688 if v.ResourceId == nil { 1689 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 1690 } 1691 if invalidParams.Len() > 0 { 1692 return invalidParams 1693 } else { 1694 return nil 1695 } 1696} 1697 1698func validateResourceKeys(v []types.ResourceKey) error { 1699 if v == nil { 1700 return nil 1701 } 1702 invalidParams := smithy.InvalidParamsError{Context: "ResourceKeys"} 1703 for i := range v { 1704 if err := validateResourceKey(&v[i]); err != nil { 1705 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1706 } 1707 } 1708 if invalidParams.Len() > 0 { 1709 return invalidParams 1710 } else { 1711 return nil 1712 } 1713} 1714 1715func validateResourceValue(v *types.ResourceValue) error { 1716 if v == nil { 1717 return nil 1718 } 1719 invalidParams := smithy.InvalidParamsError{Context: "ResourceValue"} 1720 if len(v.Value) == 0 { 1721 invalidParams.Add(smithy.NewErrParamRequired("Value")) 1722 } 1723 if invalidParams.Len() > 0 { 1724 return invalidParams 1725 } else { 1726 return nil 1727 } 1728} 1729 1730func validateSource(v *types.Source) error { 1731 if v == nil { 1732 return nil 1733 } 1734 invalidParams := smithy.InvalidParamsError{Context: "Source"} 1735 if len(v.Owner) == 0 { 1736 invalidParams.Add(smithy.NewErrParamRequired("Owner")) 1737 } 1738 if v.SourceIdentifier == nil { 1739 invalidParams.Add(smithy.NewErrParamRequired("SourceIdentifier")) 1740 } 1741 if invalidParams.Len() > 0 { 1742 return invalidParams 1743 } else { 1744 return nil 1745 } 1746} 1747 1748func validateStaticValue(v *types.StaticValue) error { 1749 if v == nil { 1750 return nil 1751 } 1752 invalidParams := smithy.InvalidParamsError{Context: "StaticValue"} 1753 if v.Values == nil { 1754 invalidParams.Add(smithy.NewErrParamRequired("Values")) 1755 } 1756 if invalidParams.Len() > 0 { 1757 return invalidParams 1758 } else { 1759 return nil 1760 } 1761} 1762 1763func validateOpBatchGetAggregateResourceConfigInput(v *BatchGetAggregateResourceConfigInput) error { 1764 if v == nil { 1765 return nil 1766 } 1767 invalidParams := smithy.InvalidParamsError{Context: "BatchGetAggregateResourceConfigInput"} 1768 if v.ConfigurationAggregatorName == nil { 1769 invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName")) 1770 } 1771 if v.ResourceIdentifiers == nil { 1772 invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifiers")) 1773 } else if v.ResourceIdentifiers != nil { 1774 if err := validateResourceIdentifiersList(v.ResourceIdentifiers); err != nil { 1775 invalidParams.AddNested("ResourceIdentifiers", err.(smithy.InvalidParamsError)) 1776 } 1777 } 1778 if invalidParams.Len() > 0 { 1779 return invalidParams 1780 } else { 1781 return nil 1782 } 1783} 1784 1785func validateOpBatchGetResourceConfigInput(v *BatchGetResourceConfigInput) error { 1786 if v == nil { 1787 return nil 1788 } 1789 invalidParams := smithy.InvalidParamsError{Context: "BatchGetResourceConfigInput"} 1790 if v.ResourceKeys == nil { 1791 invalidParams.Add(smithy.NewErrParamRequired("ResourceKeys")) 1792 } else if v.ResourceKeys != nil { 1793 if err := validateResourceKeys(v.ResourceKeys); err != nil { 1794 invalidParams.AddNested("ResourceKeys", err.(smithy.InvalidParamsError)) 1795 } 1796 } 1797 if invalidParams.Len() > 0 { 1798 return invalidParams 1799 } else { 1800 return nil 1801 } 1802} 1803 1804func validateOpDeleteAggregationAuthorizationInput(v *DeleteAggregationAuthorizationInput) error { 1805 if v == nil { 1806 return nil 1807 } 1808 invalidParams := smithy.InvalidParamsError{Context: "DeleteAggregationAuthorizationInput"} 1809 if v.AuthorizedAccountId == nil { 1810 invalidParams.Add(smithy.NewErrParamRequired("AuthorizedAccountId")) 1811 } 1812 if v.AuthorizedAwsRegion == nil { 1813 invalidParams.Add(smithy.NewErrParamRequired("AuthorizedAwsRegion")) 1814 } 1815 if invalidParams.Len() > 0 { 1816 return invalidParams 1817 } else { 1818 return nil 1819 } 1820} 1821 1822func validateOpDeleteConfigRuleInput(v *DeleteConfigRuleInput) error { 1823 if v == nil { 1824 return nil 1825 } 1826 invalidParams := smithy.InvalidParamsError{Context: "DeleteConfigRuleInput"} 1827 if v.ConfigRuleName == nil { 1828 invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName")) 1829 } 1830 if invalidParams.Len() > 0 { 1831 return invalidParams 1832 } else { 1833 return nil 1834 } 1835} 1836 1837func validateOpDeleteConfigurationAggregatorInput(v *DeleteConfigurationAggregatorInput) error { 1838 if v == nil { 1839 return nil 1840 } 1841 invalidParams := smithy.InvalidParamsError{Context: "DeleteConfigurationAggregatorInput"} 1842 if v.ConfigurationAggregatorName == nil { 1843 invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName")) 1844 } 1845 if invalidParams.Len() > 0 { 1846 return invalidParams 1847 } else { 1848 return nil 1849 } 1850} 1851 1852func validateOpDeleteConfigurationRecorderInput(v *DeleteConfigurationRecorderInput) error { 1853 if v == nil { 1854 return nil 1855 } 1856 invalidParams := smithy.InvalidParamsError{Context: "DeleteConfigurationRecorderInput"} 1857 if v.ConfigurationRecorderName == nil { 1858 invalidParams.Add(smithy.NewErrParamRequired("ConfigurationRecorderName")) 1859 } 1860 if invalidParams.Len() > 0 { 1861 return invalidParams 1862 } else { 1863 return nil 1864 } 1865} 1866 1867func validateOpDeleteConformancePackInput(v *DeleteConformancePackInput) error { 1868 if v == nil { 1869 return nil 1870 } 1871 invalidParams := smithy.InvalidParamsError{Context: "DeleteConformancePackInput"} 1872 if v.ConformancePackName == nil { 1873 invalidParams.Add(smithy.NewErrParamRequired("ConformancePackName")) 1874 } 1875 if invalidParams.Len() > 0 { 1876 return invalidParams 1877 } else { 1878 return nil 1879 } 1880} 1881 1882func validateOpDeleteDeliveryChannelInput(v *DeleteDeliveryChannelInput) error { 1883 if v == nil { 1884 return nil 1885 } 1886 invalidParams := smithy.InvalidParamsError{Context: "DeleteDeliveryChannelInput"} 1887 if v.DeliveryChannelName == nil { 1888 invalidParams.Add(smithy.NewErrParamRequired("DeliveryChannelName")) 1889 } 1890 if invalidParams.Len() > 0 { 1891 return invalidParams 1892 } else { 1893 return nil 1894 } 1895} 1896 1897func validateOpDeleteEvaluationResultsInput(v *DeleteEvaluationResultsInput) error { 1898 if v == nil { 1899 return nil 1900 } 1901 invalidParams := smithy.InvalidParamsError{Context: "DeleteEvaluationResultsInput"} 1902 if v.ConfigRuleName == nil { 1903 invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName")) 1904 } 1905 if invalidParams.Len() > 0 { 1906 return invalidParams 1907 } else { 1908 return nil 1909 } 1910} 1911 1912func validateOpDeleteOrganizationConfigRuleInput(v *DeleteOrganizationConfigRuleInput) error { 1913 if v == nil { 1914 return nil 1915 } 1916 invalidParams := smithy.InvalidParamsError{Context: "DeleteOrganizationConfigRuleInput"} 1917 if v.OrganizationConfigRuleName == nil { 1918 invalidParams.Add(smithy.NewErrParamRequired("OrganizationConfigRuleName")) 1919 } 1920 if invalidParams.Len() > 0 { 1921 return invalidParams 1922 } else { 1923 return nil 1924 } 1925} 1926 1927func validateOpDeleteOrganizationConformancePackInput(v *DeleteOrganizationConformancePackInput) error { 1928 if v == nil { 1929 return nil 1930 } 1931 invalidParams := smithy.InvalidParamsError{Context: "DeleteOrganizationConformancePackInput"} 1932 if v.OrganizationConformancePackName == nil { 1933 invalidParams.Add(smithy.NewErrParamRequired("OrganizationConformancePackName")) 1934 } 1935 if invalidParams.Len() > 0 { 1936 return invalidParams 1937 } else { 1938 return nil 1939 } 1940} 1941 1942func validateOpDeletePendingAggregationRequestInput(v *DeletePendingAggregationRequestInput) error { 1943 if v == nil { 1944 return nil 1945 } 1946 invalidParams := smithy.InvalidParamsError{Context: "DeletePendingAggregationRequestInput"} 1947 if v.RequesterAccountId == nil { 1948 invalidParams.Add(smithy.NewErrParamRequired("RequesterAccountId")) 1949 } 1950 if v.RequesterAwsRegion == nil { 1951 invalidParams.Add(smithy.NewErrParamRequired("RequesterAwsRegion")) 1952 } 1953 if invalidParams.Len() > 0 { 1954 return invalidParams 1955 } else { 1956 return nil 1957 } 1958} 1959 1960func validateOpDeleteRemediationConfigurationInput(v *DeleteRemediationConfigurationInput) error { 1961 if v == nil { 1962 return nil 1963 } 1964 invalidParams := smithy.InvalidParamsError{Context: "DeleteRemediationConfigurationInput"} 1965 if v.ConfigRuleName == nil { 1966 invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName")) 1967 } 1968 if invalidParams.Len() > 0 { 1969 return invalidParams 1970 } else { 1971 return nil 1972 } 1973} 1974 1975func validateOpDeleteRemediationExceptionsInput(v *DeleteRemediationExceptionsInput) error { 1976 if v == nil { 1977 return nil 1978 } 1979 invalidParams := smithy.InvalidParamsError{Context: "DeleteRemediationExceptionsInput"} 1980 if v.ConfigRuleName == nil { 1981 invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName")) 1982 } 1983 if v.ResourceKeys == nil { 1984 invalidParams.Add(smithy.NewErrParamRequired("ResourceKeys")) 1985 } 1986 if invalidParams.Len() > 0 { 1987 return invalidParams 1988 } else { 1989 return nil 1990 } 1991} 1992 1993func validateOpDeleteResourceConfigInput(v *DeleteResourceConfigInput) error { 1994 if v == nil { 1995 return nil 1996 } 1997 invalidParams := smithy.InvalidParamsError{Context: "DeleteResourceConfigInput"} 1998 if v.ResourceType == nil { 1999 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 2000 } 2001 if v.ResourceId == nil { 2002 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 2003 } 2004 if invalidParams.Len() > 0 { 2005 return invalidParams 2006 } else { 2007 return nil 2008 } 2009} 2010 2011func validateOpDeleteRetentionConfigurationInput(v *DeleteRetentionConfigurationInput) error { 2012 if v == nil { 2013 return nil 2014 } 2015 invalidParams := smithy.InvalidParamsError{Context: "DeleteRetentionConfigurationInput"} 2016 if v.RetentionConfigurationName == nil { 2017 invalidParams.Add(smithy.NewErrParamRequired("RetentionConfigurationName")) 2018 } 2019 if invalidParams.Len() > 0 { 2020 return invalidParams 2021 } else { 2022 return nil 2023 } 2024} 2025 2026func validateOpDeliverConfigSnapshotInput(v *DeliverConfigSnapshotInput) error { 2027 if v == nil { 2028 return nil 2029 } 2030 invalidParams := smithy.InvalidParamsError{Context: "DeliverConfigSnapshotInput"} 2031 if v.DeliveryChannelName == nil { 2032 invalidParams.Add(smithy.NewErrParamRequired("DeliveryChannelName")) 2033 } 2034 if invalidParams.Len() > 0 { 2035 return invalidParams 2036 } else { 2037 return nil 2038 } 2039} 2040 2041func validateOpDescribeAggregateComplianceByConfigRulesInput(v *DescribeAggregateComplianceByConfigRulesInput) error { 2042 if v == nil { 2043 return nil 2044 } 2045 invalidParams := smithy.InvalidParamsError{Context: "DescribeAggregateComplianceByConfigRulesInput"} 2046 if v.ConfigurationAggregatorName == nil { 2047 invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName")) 2048 } 2049 if invalidParams.Len() > 0 { 2050 return invalidParams 2051 } else { 2052 return nil 2053 } 2054} 2055 2056func validateOpDescribeConfigurationAggregatorSourcesStatusInput(v *DescribeConfigurationAggregatorSourcesStatusInput) error { 2057 if v == nil { 2058 return nil 2059 } 2060 invalidParams := smithy.InvalidParamsError{Context: "DescribeConfigurationAggregatorSourcesStatusInput"} 2061 if v.ConfigurationAggregatorName == nil { 2062 invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName")) 2063 } 2064 if invalidParams.Len() > 0 { 2065 return invalidParams 2066 } else { 2067 return nil 2068 } 2069} 2070 2071func validateOpDescribeConformancePackComplianceInput(v *DescribeConformancePackComplianceInput) error { 2072 if v == nil { 2073 return nil 2074 } 2075 invalidParams := smithy.InvalidParamsError{Context: "DescribeConformancePackComplianceInput"} 2076 if v.ConformancePackName == nil { 2077 invalidParams.Add(smithy.NewErrParamRequired("ConformancePackName")) 2078 } 2079 if invalidParams.Len() > 0 { 2080 return invalidParams 2081 } else { 2082 return nil 2083 } 2084} 2085 2086func validateOpDescribeRemediationConfigurationsInput(v *DescribeRemediationConfigurationsInput) error { 2087 if v == nil { 2088 return nil 2089 } 2090 invalidParams := smithy.InvalidParamsError{Context: "DescribeRemediationConfigurationsInput"} 2091 if v.ConfigRuleNames == nil { 2092 invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleNames")) 2093 } 2094 if invalidParams.Len() > 0 { 2095 return invalidParams 2096 } else { 2097 return nil 2098 } 2099} 2100 2101func validateOpDescribeRemediationExceptionsInput(v *DescribeRemediationExceptionsInput) error { 2102 if v == nil { 2103 return nil 2104 } 2105 invalidParams := smithy.InvalidParamsError{Context: "DescribeRemediationExceptionsInput"} 2106 if v.ConfigRuleName == nil { 2107 invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName")) 2108 } 2109 if invalidParams.Len() > 0 { 2110 return invalidParams 2111 } else { 2112 return nil 2113 } 2114} 2115 2116func validateOpDescribeRemediationExecutionStatusInput(v *DescribeRemediationExecutionStatusInput) error { 2117 if v == nil { 2118 return nil 2119 } 2120 invalidParams := smithy.InvalidParamsError{Context: "DescribeRemediationExecutionStatusInput"} 2121 if v.ConfigRuleName == nil { 2122 invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName")) 2123 } 2124 if v.ResourceKeys != nil { 2125 if err := validateResourceKeys(v.ResourceKeys); err != nil { 2126 invalidParams.AddNested("ResourceKeys", err.(smithy.InvalidParamsError)) 2127 } 2128 } 2129 if invalidParams.Len() > 0 { 2130 return invalidParams 2131 } else { 2132 return nil 2133 } 2134} 2135 2136func validateOpGetAggregateComplianceDetailsByConfigRuleInput(v *GetAggregateComplianceDetailsByConfigRuleInput) error { 2137 if v == nil { 2138 return nil 2139 } 2140 invalidParams := smithy.InvalidParamsError{Context: "GetAggregateComplianceDetailsByConfigRuleInput"} 2141 if v.ConfigurationAggregatorName == nil { 2142 invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName")) 2143 } 2144 if v.ConfigRuleName == nil { 2145 invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName")) 2146 } 2147 if v.AccountId == nil { 2148 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 2149 } 2150 if v.AwsRegion == nil { 2151 invalidParams.Add(smithy.NewErrParamRequired("AwsRegion")) 2152 } 2153 if invalidParams.Len() > 0 { 2154 return invalidParams 2155 } else { 2156 return nil 2157 } 2158} 2159 2160func validateOpGetAggregateConfigRuleComplianceSummaryInput(v *GetAggregateConfigRuleComplianceSummaryInput) error { 2161 if v == nil { 2162 return nil 2163 } 2164 invalidParams := smithy.InvalidParamsError{Context: "GetAggregateConfigRuleComplianceSummaryInput"} 2165 if v.ConfigurationAggregatorName == nil { 2166 invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName")) 2167 } 2168 if invalidParams.Len() > 0 { 2169 return invalidParams 2170 } else { 2171 return nil 2172 } 2173} 2174 2175func validateOpGetAggregateDiscoveredResourceCountsInput(v *GetAggregateDiscoveredResourceCountsInput) error { 2176 if v == nil { 2177 return nil 2178 } 2179 invalidParams := smithy.InvalidParamsError{Context: "GetAggregateDiscoveredResourceCountsInput"} 2180 if v.ConfigurationAggregatorName == nil { 2181 invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName")) 2182 } 2183 if invalidParams.Len() > 0 { 2184 return invalidParams 2185 } else { 2186 return nil 2187 } 2188} 2189 2190func validateOpGetAggregateResourceConfigInput(v *GetAggregateResourceConfigInput) error { 2191 if v == nil { 2192 return nil 2193 } 2194 invalidParams := smithy.InvalidParamsError{Context: "GetAggregateResourceConfigInput"} 2195 if v.ConfigurationAggregatorName == nil { 2196 invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName")) 2197 } 2198 if v.ResourceIdentifier == nil { 2199 invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier")) 2200 } else if v.ResourceIdentifier != nil { 2201 if err := validateAggregateResourceIdentifier(v.ResourceIdentifier); err != nil { 2202 invalidParams.AddNested("ResourceIdentifier", err.(smithy.InvalidParamsError)) 2203 } 2204 } 2205 if invalidParams.Len() > 0 { 2206 return invalidParams 2207 } else { 2208 return nil 2209 } 2210} 2211 2212func validateOpGetComplianceDetailsByConfigRuleInput(v *GetComplianceDetailsByConfigRuleInput) error { 2213 if v == nil { 2214 return nil 2215 } 2216 invalidParams := smithy.InvalidParamsError{Context: "GetComplianceDetailsByConfigRuleInput"} 2217 if v.ConfigRuleName == nil { 2218 invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName")) 2219 } 2220 if invalidParams.Len() > 0 { 2221 return invalidParams 2222 } else { 2223 return nil 2224 } 2225} 2226 2227func validateOpGetComplianceDetailsByResourceInput(v *GetComplianceDetailsByResourceInput) error { 2228 if v == nil { 2229 return nil 2230 } 2231 invalidParams := smithy.InvalidParamsError{Context: "GetComplianceDetailsByResourceInput"} 2232 if v.ResourceType == nil { 2233 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 2234 } 2235 if v.ResourceId == nil { 2236 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 2237 } 2238 if invalidParams.Len() > 0 { 2239 return invalidParams 2240 } else { 2241 return nil 2242 } 2243} 2244 2245func validateOpGetConformancePackComplianceDetailsInput(v *GetConformancePackComplianceDetailsInput) error { 2246 if v == nil { 2247 return nil 2248 } 2249 invalidParams := smithy.InvalidParamsError{Context: "GetConformancePackComplianceDetailsInput"} 2250 if v.ConformancePackName == nil { 2251 invalidParams.Add(smithy.NewErrParamRequired("ConformancePackName")) 2252 } 2253 if invalidParams.Len() > 0 { 2254 return invalidParams 2255 } else { 2256 return nil 2257 } 2258} 2259 2260func validateOpGetConformancePackComplianceSummaryInput(v *GetConformancePackComplianceSummaryInput) error { 2261 if v == nil { 2262 return nil 2263 } 2264 invalidParams := smithy.InvalidParamsError{Context: "GetConformancePackComplianceSummaryInput"} 2265 if v.ConformancePackNames == nil { 2266 invalidParams.Add(smithy.NewErrParamRequired("ConformancePackNames")) 2267 } 2268 if invalidParams.Len() > 0 { 2269 return invalidParams 2270 } else { 2271 return nil 2272 } 2273} 2274 2275func validateOpGetOrganizationConfigRuleDetailedStatusInput(v *GetOrganizationConfigRuleDetailedStatusInput) error { 2276 if v == nil { 2277 return nil 2278 } 2279 invalidParams := smithy.InvalidParamsError{Context: "GetOrganizationConfigRuleDetailedStatusInput"} 2280 if v.OrganizationConfigRuleName == nil { 2281 invalidParams.Add(smithy.NewErrParamRequired("OrganizationConfigRuleName")) 2282 } 2283 if invalidParams.Len() > 0 { 2284 return invalidParams 2285 } else { 2286 return nil 2287 } 2288} 2289 2290func validateOpGetOrganizationConformancePackDetailedStatusInput(v *GetOrganizationConformancePackDetailedStatusInput) error { 2291 if v == nil { 2292 return nil 2293 } 2294 invalidParams := smithy.InvalidParamsError{Context: "GetOrganizationConformancePackDetailedStatusInput"} 2295 if v.OrganizationConformancePackName == nil { 2296 invalidParams.Add(smithy.NewErrParamRequired("OrganizationConformancePackName")) 2297 } 2298 if invalidParams.Len() > 0 { 2299 return invalidParams 2300 } else { 2301 return nil 2302 } 2303} 2304 2305func validateOpGetResourceConfigHistoryInput(v *GetResourceConfigHistoryInput) error { 2306 if v == nil { 2307 return nil 2308 } 2309 invalidParams := smithy.InvalidParamsError{Context: "GetResourceConfigHistoryInput"} 2310 if len(v.ResourceType) == 0 { 2311 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 2312 } 2313 if v.ResourceId == nil { 2314 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 2315 } 2316 if invalidParams.Len() > 0 { 2317 return invalidParams 2318 } else { 2319 return nil 2320 } 2321} 2322 2323func validateOpListAggregateDiscoveredResourcesInput(v *ListAggregateDiscoveredResourcesInput) error { 2324 if v == nil { 2325 return nil 2326 } 2327 invalidParams := smithy.InvalidParamsError{Context: "ListAggregateDiscoveredResourcesInput"} 2328 if v.ConfigurationAggregatorName == nil { 2329 invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName")) 2330 } 2331 if len(v.ResourceType) == 0 { 2332 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 2333 } 2334 if invalidParams.Len() > 0 { 2335 return invalidParams 2336 } else { 2337 return nil 2338 } 2339} 2340 2341func validateOpListDiscoveredResourcesInput(v *ListDiscoveredResourcesInput) error { 2342 if v == nil { 2343 return nil 2344 } 2345 invalidParams := smithy.InvalidParamsError{Context: "ListDiscoveredResourcesInput"} 2346 if len(v.ResourceType) == 0 { 2347 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 2348 } 2349 if invalidParams.Len() > 0 { 2350 return invalidParams 2351 } else { 2352 return nil 2353 } 2354} 2355 2356func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 2357 if v == nil { 2358 return nil 2359 } 2360 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 2361 if v.ResourceArn == nil { 2362 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2363 } 2364 if invalidParams.Len() > 0 { 2365 return invalidParams 2366 } else { 2367 return nil 2368 } 2369} 2370 2371func validateOpPutAggregationAuthorizationInput(v *PutAggregationAuthorizationInput) error { 2372 if v == nil { 2373 return nil 2374 } 2375 invalidParams := smithy.InvalidParamsError{Context: "PutAggregationAuthorizationInput"} 2376 if v.AuthorizedAccountId == nil { 2377 invalidParams.Add(smithy.NewErrParamRequired("AuthorizedAccountId")) 2378 } 2379 if v.AuthorizedAwsRegion == nil { 2380 invalidParams.Add(smithy.NewErrParamRequired("AuthorizedAwsRegion")) 2381 } 2382 if invalidParams.Len() > 0 { 2383 return invalidParams 2384 } else { 2385 return nil 2386 } 2387} 2388 2389func validateOpPutConfigRuleInput(v *PutConfigRuleInput) error { 2390 if v == nil { 2391 return nil 2392 } 2393 invalidParams := smithy.InvalidParamsError{Context: "PutConfigRuleInput"} 2394 if v.ConfigRule == nil { 2395 invalidParams.Add(smithy.NewErrParamRequired("ConfigRule")) 2396 } else if v.ConfigRule != nil { 2397 if err := validateConfigRule(v.ConfigRule); err != nil { 2398 invalidParams.AddNested("ConfigRule", err.(smithy.InvalidParamsError)) 2399 } 2400 } 2401 if invalidParams.Len() > 0 { 2402 return invalidParams 2403 } else { 2404 return nil 2405 } 2406} 2407 2408func validateOpPutConfigurationAggregatorInput(v *PutConfigurationAggregatorInput) error { 2409 if v == nil { 2410 return nil 2411 } 2412 invalidParams := smithy.InvalidParamsError{Context: "PutConfigurationAggregatorInput"} 2413 if v.ConfigurationAggregatorName == nil { 2414 invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName")) 2415 } 2416 if v.AccountAggregationSources != nil { 2417 if err := validateAccountAggregationSourceList(v.AccountAggregationSources); err != nil { 2418 invalidParams.AddNested("AccountAggregationSources", err.(smithy.InvalidParamsError)) 2419 } 2420 } 2421 if v.OrganizationAggregationSource != nil { 2422 if err := validateOrganizationAggregationSource(v.OrganizationAggregationSource); err != nil { 2423 invalidParams.AddNested("OrganizationAggregationSource", err.(smithy.InvalidParamsError)) 2424 } 2425 } 2426 if invalidParams.Len() > 0 { 2427 return invalidParams 2428 } else { 2429 return nil 2430 } 2431} 2432 2433func validateOpPutConfigurationRecorderInput(v *PutConfigurationRecorderInput) error { 2434 if v == nil { 2435 return nil 2436 } 2437 invalidParams := smithy.InvalidParamsError{Context: "PutConfigurationRecorderInput"} 2438 if v.ConfigurationRecorder == nil { 2439 invalidParams.Add(smithy.NewErrParamRequired("ConfigurationRecorder")) 2440 } 2441 if invalidParams.Len() > 0 { 2442 return invalidParams 2443 } else { 2444 return nil 2445 } 2446} 2447 2448func validateOpPutConformancePackInput(v *PutConformancePackInput) error { 2449 if v == nil { 2450 return nil 2451 } 2452 invalidParams := smithy.InvalidParamsError{Context: "PutConformancePackInput"} 2453 if v.ConformancePackName == nil { 2454 invalidParams.Add(smithy.NewErrParamRequired("ConformancePackName")) 2455 } 2456 if v.ConformancePackInputParameters != nil { 2457 if err := validateConformancePackInputParameters(v.ConformancePackInputParameters); err != nil { 2458 invalidParams.AddNested("ConformancePackInputParameters", err.(smithy.InvalidParamsError)) 2459 } 2460 } 2461 if invalidParams.Len() > 0 { 2462 return invalidParams 2463 } else { 2464 return nil 2465 } 2466} 2467 2468func validateOpPutDeliveryChannelInput(v *PutDeliveryChannelInput) error { 2469 if v == nil { 2470 return nil 2471 } 2472 invalidParams := smithy.InvalidParamsError{Context: "PutDeliveryChannelInput"} 2473 if v.DeliveryChannel == nil { 2474 invalidParams.Add(smithy.NewErrParamRequired("DeliveryChannel")) 2475 } 2476 if invalidParams.Len() > 0 { 2477 return invalidParams 2478 } else { 2479 return nil 2480 } 2481} 2482 2483func validateOpPutEvaluationsInput(v *PutEvaluationsInput) error { 2484 if v == nil { 2485 return nil 2486 } 2487 invalidParams := smithy.InvalidParamsError{Context: "PutEvaluationsInput"} 2488 if v.Evaluations != nil { 2489 if err := validateEvaluations(v.Evaluations); err != nil { 2490 invalidParams.AddNested("Evaluations", err.(smithy.InvalidParamsError)) 2491 } 2492 } 2493 if v.ResultToken == nil { 2494 invalidParams.Add(smithy.NewErrParamRequired("ResultToken")) 2495 } 2496 if invalidParams.Len() > 0 { 2497 return invalidParams 2498 } else { 2499 return nil 2500 } 2501} 2502 2503func validateOpPutOrganizationConfigRuleInput(v *PutOrganizationConfigRuleInput) error { 2504 if v == nil { 2505 return nil 2506 } 2507 invalidParams := smithy.InvalidParamsError{Context: "PutOrganizationConfigRuleInput"} 2508 if v.OrganizationConfigRuleName == nil { 2509 invalidParams.Add(smithy.NewErrParamRequired("OrganizationConfigRuleName")) 2510 } 2511 if v.OrganizationManagedRuleMetadata != nil { 2512 if err := validateOrganizationManagedRuleMetadata(v.OrganizationManagedRuleMetadata); err != nil { 2513 invalidParams.AddNested("OrganizationManagedRuleMetadata", err.(smithy.InvalidParamsError)) 2514 } 2515 } 2516 if v.OrganizationCustomRuleMetadata != nil { 2517 if err := validateOrganizationCustomRuleMetadata(v.OrganizationCustomRuleMetadata); err != nil { 2518 invalidParams.AddNested("OrganizationCustomRuleMetadata", err.(smithy.InvalidParamsError)) 2519 } 2520 } 2521 if invalidParams.Len() > 0 { 2522 return invalidParams 2523 } else { 2524 return nil 2525 } 2526} 2527 2528func validateOpPutOrganizationConformancePackInput(v *PutOrganizationConformancePackInput) error { 2529 if v == nil { 2530 return nil 2531 } 2532 invalidParams := smithy.InvalidParamsError{Context: "PutOrganizationConformancePackInput"} 2533 if v.OrganizationConformancePackName == nil { 2534 invalidParams.Add(smithy.NewErrParamRequired("OrganizationConformancePackName")) 2535 } 2536 if v.ConformancePackInputParameters != nil { 2537 if err := validateConformancePackInputParameters(v.ConformancePackInputParameters); err != nil { 2538 invalidParams.AddNested("ConformancePackInputParameters", err.(smithy.InvalidParamsError)) 2539 } 2540 } 2541 if invalidParams.Len() > 0 { 2542 return invalidParams 2543 } else { 2544 return nil 2545 } 2546} 2547 2548func validateOpPutRemediationConfigurationsInput(v *PutRemediationConfigurationsInput) error { 2549 if v == nil { 2550 return nil 2551 } 2552 invalidParams := smithy.InvalidParamsError{Context: "PutRemediationConfigurationsInput"} 2553 if v.RemediationConfigurations == nil { 2554 invalidParams.Add(smithy.NewErrParamRequired("RemediationConfigurations")) 2555 } else if v.RemediationConfigurations != nil { 2556 if err := validateRemediationConfigurations(v.RemediationConfigurations); err != nil { 2557 invalidParams.AddNested("RemediationConfigurations", err.(smithy.InvalidParamsError)) 2558 } 2559 } 2560 if invalidParams.Len() > 0 { 2561 return invalidParams 2562 } else { 2563 return nil 2564 } 2565} 2566 2567func validateOpPutRemediationExceptionsInput(v *PutRemediationExceptionsInput) error { 2568 if v == nil { 2569 return nil 2570 } 2571 invalidParams := smithy.InvalidParamsError{Context: "PutRemediationExceptionsInput"} 2572 if v.ConfigRuleName == nil { 2573 invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName")) 2574 } 2575 if v.ResourceKeys == nil { 2576 invalidParams.Add(smithy.NewErrParamRequired("ResourceKeys")) 2577 } 2578 if invalidParams.Len() > 0 { 2579 return invalidParams 2580 } else { 2581 return nil 2582 } 2583} 2584 2585func validateOpPutResourceConfigInput(v *PutResourceConfigInput) error { 2586 if v == nil { 2587 return nil 2588 } 2589 invalidParams := smithy.InvalidParamsError{Context: "PutResourceConfigInput"} 2590 if v.ResourceType == nil { 2591 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 2592 } 2593 if v.SchemaVersionId == nil { 2594 invalidParams.Add(smithy.NewErrParamRequired("SchemaVersionId")) 2595 } 2596 if v.ResourceId == nil { 2597 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 2598 } 2599 if v.Configuration == nil { 2600 invalidParams.Add(smithy.NewErrParamRequired("Configuration")) 2601 } 2602 if invalidParams.Len() > 0 { 2603 return invalidParams 2604 } else { 2605 return nil 2606 } 2607} 2608 2609func validateOpPutRetentionConfigurationInput(v *PutRetentionConfigurationInput) error { 2610 if v == nil { 2611 return nil 2612 } 2613 invalidParams := smithy.InvalidParamsError{Context: "PutRetentionConfigurationInput"} 2614 if invalidParams.Len() > 0 { 2615 return invalidParams 2616 } else { 2617 return nil 2618 } 2619} 2620 2621func validateOpSelectAggregateResourceConfigInput(v *SelectAggregateResourceConfigInput) error { 2622 if v == nil { 2623 return nil 2624 } 2625 invalidParams := smithy.InvalidParamsError{Context: "SelectAggregateResourceConfigInput"} 2626 if v.Expression == nil { 2627 invalidParams.Add(smithy.NewErrParamRequired("Expression")) 2628 } 2629 if v.ConfigurationAggregatorName == nil { 2630 invalidParams.Add(smithy.NewErrParamRequired("ConfigurationAggregatorName")) 2631 } 2632 if invalidParams.Len() > 0 { 2633 return invalidParams 2634 } else { 2635 return nil 2636 } 2637} 2638 2639func validateOpSelectResourceConfigInput(v *SelectResourceConfigInput) error { 2640 if v == nil { 2641 return nil 2642 } 2643 invalidParams := smithy.InvalidParamsError{Context: "SelectResourceConfigInput"} 2644 if v.Expression == nil { 2645 invalidParams.Add(smithy.NewErrParamRequired("Expression")) 2646 } 2647 if invalidParams.Len() > 0 { 2648 return invalidParams 2649 } else { 2650 return nil 2651 } 2652} 2653 2654func validateOpStartConfigurationRecorderInput(v *StartConfigurationRecorderInput) error { 2655 if v == nil { 2656 return nil 2657 } 2658 invalidParams := smithy.InvalidParamsError{Context: "StartConfigurationRecorderInput"} 2659 if v.ConfigurationRecorderName == nil { 2660 invalidParams.Add(smithy.NewErrParamRequired("ConfigurationRecorderName")) 2661 } 2662 if invalidParams.Len() > 0 { 2663 return invalidParams 2664 } else { 2665 return nil 2666 } 2667} 2668 2669func validateOpStartRemediationExecutionInput(v *StartRemediationExecutionInput) error { 2670 if v == nil { 2671 return nil 2672 } 2673 invalidParams := smithy.InvalidParamsError{Context: "StartRemediationExecutionInput"} 2674 if v.ConfigRuleName == nil { 2675 invalidParams.Add(smithy.NewErrParamRequired("ConfigRuleName")) 2676 } 2677 if v.ResourceKeys == nil { 2678 invalidParams.Add(smithy.NewErrParamRequired("ResourceKeys")) 2679 } else if v.ResourceKeys != nil { 2680 if err := validateResourceKeys(v.ResourceKeys); err != nil { 2681 invalidParams.AddNested("ResourceKeys", err.(smithy.InvalidParamsError)) 2682 } 2683 } 2684 if invalidParams.Len() > 0 { 2685 return invalidParams 2686 } else { 2687 return nil 2688 } 2689} 2690 2691func validateOpStopConfigurationRecorderInput(v *StopConfigurationRecorderInput) error { 2692 if v == nil { 2693 return nil 2694 } 2695 invalidParams := smithy.InvalidParamsError{Context: "StopConfigurationRecorderInput"} 2696 if v.ConfigurationRecorderName == nil { 2697 invalidParams.Add(smithy.NewErrParamRequired("ConfigurationRecorderName")) 2698 } 2699 if invalidParams.Len() > 0 { 2700 return invalidParams 2701 } else { 2702 return nil 2703 } 2704} 2705 2706func validateOpTagResourceInput(v *TagResourceInput) error { 2707 if v == nil { 2708 return nil 2709 } 2710 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 2711 if v.ResourceArn == nil { 2712 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2713 } 2714 if v.Tags == nil { 2715 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 2716 } 2717 if invalidParams.Len() > 0 { 2718 return invalidParams 2719 } else { 2720 return nil 2721 } 2722} 2723 2724func validateOpUntagResourceInput(v *UntagResourceInput) error { 2725 if v == nil { 2726 return nil 2727 } 2728 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 2729 if v.ResourceArn == nil { 2730 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2731 } 2732 if v.TagKeys == nil { 2733 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 2734 } 2735 if invalidParams.Len() > 0 { 2736 return invalidParams 2737 } else { 2738 return nil 2739 } 2740} 2741