1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package ssm 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/ssm/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpAddTagsToResource struct { 14} 15 16func (*validateOpAddTagsToResource) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpAddTagsToResource) 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.(*AddTagsToResourceInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpAddTagsToResourceInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpCancelCommand struct { 34} 35 36func (*validateOpCancelCommand) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpCancelCommand) 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.(*CancelCommandInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpCancelCommandInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCancelMaintenanceWindowExecution struct { 54} 55 56func (*validateOpCancelMaintenanceWindowExecution) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCancelMaintenanceWindowExecution) 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.(*CancelMaintenanceWindowExecutionInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCancelMaintenanceWindowExecutionInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateActivation struct { 74} 75 76func (*validateOpCreateActivation) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateActivation) 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.(*CreateActivationInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateActivationInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateAssociationBatch struct { 94} 95 96func (*validateOpCreateAssociationBatch) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateAssociationBatch) 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.(*CreateAssociationBatchInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateAssociationBatchInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateAssociation struct { 114} 115 116func (*validateOpCreateAssociation) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateAssociation) 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.(*CreateAssociationInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateAssociationInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpCreateDocument struct { 134} 135 136func (*validateOpCreateDocument) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpCreateDocument) 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.(*CreateDocumentInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpCreateDocumentInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpCreateMaintenanceWindow struct { 154} 155 156func (*validateOpCreateMaintenanceWindow) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpCreateMaintenanceWindow) 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.(*CreateMaintenanceWindowInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpCreateMaintenanceWindowInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpCreateOpsItem struct { 174} 175 176func (*validateOpCreateOpsItem) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpCreateOpsItem) 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.(*CreateOpsItemInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpCreateOpsItemInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpCreateOpsMetadata struct { 194} 195 196func (*validateOpCreateOpsMetadata) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpCreateOpsMetadata) 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.(*CreateOpsMetadataInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpCreateOpsMetadataInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpCreatePatchBaseline struct { 214} 215 216func (*validateOpCreatePatchBaseline) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpCreatePatchBaseline) 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.(*CreatePatchBaselineInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpCreatePatchBaselineInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpCreateResourceDataSync struct { 234} 235 236func (*validateOpCreateResourceDataSync) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpCreateResourceDataSync) 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.(*CreateResourceDataSyncInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpCreateResourceDataSyncInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDeleteActivation struct { 254} 255 256func (*validateOpDeleteActivation) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDeleteActivation) 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.(*DeleteActivationInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDeleteActivationInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDeleteDocument struct { 274} 275 276func (*validateOpDeleteDocument) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDeleteDocument) 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.(*DeleteDocumentInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDeleteDocumentInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpDeleteInventory struct { 294} 295 296func (*validateOpDeleteInventory) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpDeleteInventory) 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.(*DeleteInventoryInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpDeleteInventoryInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpDeleteMaintenanceWindow struct { 314} 315 316func (*validateOpDeleteMaintenanceWindow) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpDeleteMaintenanceWindow) 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.(*DeleteMaintenanceWindowInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpDeleteMaintenanceWindowInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpDeleteOpsMetadata struct { 334} 335 336func (*validateOpDeleteOpsMetadata) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpDeleteOpsMetadata) 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.(*DeleteOpsMetadataInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpDeleteOpsMetadataInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpDeleteParameter struct { 354} 355 356func (*validateOpDeleteParameter) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpDeleteParameter) 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.(*DeleteParameterInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpDeleteParameterInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpDeleteParameters struct { 374} 375 376func (*validateOpDeleteParameters) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpDeleteParameters) 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.(*DeleteParametersInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpDeleteParametersInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpDeletePatchBaseline struct { 394} 395 396func (*validateOpDeletePatchBaseline) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpDeletePatchBaseline) 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.(*DeletePatchBaselineInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpDeletePatchBaselineInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpDeleteResourceDataSync struct { 414} 415 416func (*validateOpDeleteResourceDataSync) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpDeleteResourceDataSync) 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.(*DeleteResourceDataSyncInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpDeleteResourceDataSyncInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpDeregisterManagedInstance struct { 434} 435 436func (*validateOpDeregisterManagedInstance) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpDeregisterManagedInstance) 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.(*DeregisterManagedInstanceInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpDeregisterManagedInstanceInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpDeregisterPatchBaselineForPatchGroup struct { 454} 455 456func (*validateOpDeregisterPatchBaselineForPatchGroup) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpDeregisterPatchBaselineForPatchGroup) 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.(*DeregisterPatchBaselineForPatchGroupInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpDeregisterPatchBaselineForPatchGroupInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpDeregisterTargetFromMaintenanceWindow struct { 474} 475 476func (*validateOpDeregisterTargetFromMaintenanceWindow) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpDeregisterTargetFromMaintenanceWindow) 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.(*DeregisterTargetFromMaintenanceWindowInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpDeregisterTargetFromMaintenanceWindowInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpDeregisterTaskFromMaintenanceWindow struct { 494} 495 496func (*validateOpDeregisterTaskFromMaintenanceWindow) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpDeregisterTaskFromMaintenanceWindow) 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.(*DeregisterTaskFromMaintenanceWindowInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpDeregisterTaskFromMaintenanceWindowInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpDescribeAssociationExecutions struct { 514} 515 516func (*validateOpDescribeAssociationExecutions) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpDescribeAssociationExecutions) 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.(*DescribeAssociationExecutionsInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpDescribeAssociationExecutionsInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpDescribeAssociationExecutionTargets struct { 534} 535 536func (*validateOpDescribeAssociationExecutionTargets) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpDescribeAssociationExecutionTargets) 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.(*DescribeAssociationExecutionTargetsInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpDescribeAssociationExecutionTargetsInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpDescribeAutomationExecutions struct { 554} 555 556func (*validateOpDescribeAutomationExecutions) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpDescribeAutomationExecutions) 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.(*DescribeAutomationExecutionsInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpDescribeAutomationExecutionsInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpDescribeAutomationStepExecutions struct { 574} 575 576func (*validateOpDescribeAutomationStepExecutions) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpDescribeAutomationStepExecutions) 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.(*DescribeAutomationStepExecutionsInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpDescribeAutomationStepExecutionsInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpDescribeDocument struct { 594} 595 596func (*validateOpDescribeDocument) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpDescribeDocument) 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.(*DescribeDocumentInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpDescribeDocumentInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpDescribeDocumentPermission struct { 614} 615 616func (*validateOpDescribeDocumentPermission) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpDescribeDocumentPermission) 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.(*DescribeDocumentPermissionInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpDescribeDocumentPermissionInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpDescribeEffectiveInstanceAssociations struct { 634} 635 636func (*validateOpDescribeEffectiveInstanceAssociations) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpDescribeEffectiveInstanceAssociations) 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.(*DescribeEffectiveInstanceAssociationsInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpDescribeEffectiveInstanceAssociationsInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpDescribeEffectivePatchesForPatchBaseline struct { 654} 655 656func (*validateOpDescribeEffectivePatchesForPatchBaseline) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpDescribeEffectivePatchesForPatchBaseline) 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.(*DescribeEffectivePatchesForPatchBaselineInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpDescribeEffectivePatchesForPatchBaselineInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpDescribeInstanceAssociationsStatus struct { 674} 675 676func (*validateOpDescribeInstanceAssociationsStatus) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpDescribeInstanceAssociationsStatus) 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.(*DescribeInstanceAssociationsStatusInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpDescribeInstanceAssociationsStatusInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpDescribeInstanceInformation struct { 694} 695 696func (*validateOpDescribeInstanceInformation) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpDescribeInstanceInformation) 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.(*DescribeInstanceInformationInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpDescribeInstanceInformationInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpDescribeInstancePatches struct { 714} 715 716func (*validateOpDescribeInstancePatches) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpDescribeInstancePatches) 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.(*DescribeInstancePatchesInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpDescribeInstancePatchesInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpDescribeInstancePatchStatesForPatchGroup struct { 734} 735 736func (*validateOpDescribeInstancePatchStatesForPatchGroup) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpDescribeInstancePatchStatesForPatchGroup) 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.(*DescribeInstancePatchStatesForPatchGroupInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpDescribeInstancePatchStatesForPatchGroupInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753type validateOpDescribeInstancePatchStates struct { 754} 755 756func (*validateOpDescribeInstancePatchStates) ID() string { 757 return "OperationInputValidation" 758} 759 760func (m *validateOpDescribeInstancePatchStates) 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.(*DescribeInstancePatchStatesInput) 764 if !ok { 765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 766 } 767 if err := validateOpDescribeInstancePatchStatesInput(input); err != nil { 768 return out, metadata, err 769 } 770 return next.HandleInitialize(ctx, in) 771} 772 773type validateOpDescribeMaintenanceWindowExecutions struct { 774} 775 776func (*validateOpDescribeMaintenanceWindowExecutions) ID() string { 777 return "OperationInputValidation" 778} 779 780func (m *validateOpDescribeMaintenanceWindowExecutions) 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.(*DescribeMaintenanceWindowExecutionsInput) 784 if !ok { 785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 786 } 787 if err := validateOpDescribeMaintenanceWindowExecutionsInput(input); err != nil { 788 return out, metadata, err 789 } 790 return next.HandleInitialize(ctx, in) 791} 792 793type validateOpDescribeMaintenanceWindowExecutionTaskInvocations struct { 794} 795 796func (*validateOpDescribeMaintenanceWindowExecutionTaskInvocations) ID() string { 797 return "OperationInputValidation" 798} 799 800func (m *validateOpDescribeMaintenanceWindowExecutionTaskInvocations) 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.(*DescribeMaintenanceWindowExecutionTaskInvocationsInput) 804 if !ok { 805 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 806 } 807 if err := validateOpDescribeMaintenanceWindowExecutionTaskInvocationsInput(input); err != nil { 808 return out, metadata, err 809 } 810 return next.HandleInitialize(ctx, in) 811} 812 813type validateOpDescribeMaintenanceWindowExecutionTasks struct { 814} 815 816func (*validateOpDescribeMaintenanceWindowExecutionTasks) ID() string { 817 return "OperationInputValidation" 818} 819 820func (m *validateOpDescribeMaintenanceWindowExecutionTasks) 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.(*DescribeMaintenanceWindowExecutionTasksInput) 824 if !ok { 825 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 826 } 827 if err := validateOpDescribeMaintenanceWindowExecutionTasksInput(input); err != nil { 828 return out, metadata, err 829 } 830 return next.HandleInitialize(ctx, in) 831} 832 833type validateOpDescribeMaintenanceWindowsForTarget struct { 834} 835 836func (*validateOpDescribeMaintenanceWindowsForTarget) ID() string { 837 return "OperationInputValidation" 838} 839 840func (m *validateOpDescribeMaintenanceWindowsForTarget) 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.(*DescribeMaintenanceWindowsForTargetInput) 844 if !ok { 845 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 846 } 847 if err := validateOpDescribeMaintenanceWindowsForTargetInput(input); err != nil { 848 return out, metadata, err 849 } 850 return next.HandleInitialize(ctx, in) 851} 852 853type validateOpDescribeMaintenanceWindowTargets struct { 854} 855 856func (*validateOpDescribeMaintenanceWindowTargets) ID() string { 857 return "OperationInputValidation" 858} 859 860func (m *validateOpDescribeMaintenanceWindowTargets) 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.(*DescribeMaintenanceWindowTargetsInput) 864 if !ok { 865 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 866 } 867 if err := validateOpDescribeMaintenanceWindowTargetsInput(input); err != nil { 868 return out, metadata, err 869 } 870 return next.HandleInitialize(ctx, in) 871} 872 873type validateOpDescribeMaintenanceWindowTasks struct { 874} 875 876func (*validateOpDescribeMaintenanceWindowTasks) ID() string { 877 return "OperationInputValidation" 878} 879 880func (m *validateOpDescribeMaintenanceWindowTasks) 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.(*DescribeMaintenanceWindowTasksInput) 884 if !ok { 885 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 886 } 887 if err := validateOpDescribeMaintenanceWindowTasksInput(input); err != nil { 888 return out, metadata, err 889 } 890 return next.HandleInitialize(ctx, in) 891} 892 893type validateOpDescribeOpsItems struct { 894} 895 896func (*validateOpDescribeOpsItems) ID() string { 897 return "OperationInputValidation" 898} 899 900func (m *validateOpDescribeOpsItems) 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.(*DescribeOpsItemsInput) 904 if !ok { 905 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 906 } 907 if err := validateOpDescribeOpsItemsInput(input); err != nil { 908 return out, metadata, err 909 } 910 return next.HandleInitialize(ctx, in) 911} 912 913type validateOpDescribeParameters struct { 914} 915 916func (*validateOpDescribeParameters) ID() string { 917 return "OperationInputValidation" 918} 919 920func (m *validateOpDescribeParameters) 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.(*DescribeParametersInput) 924 if !ok { 925 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 926 } 927 if err := validateOpDescribeParametersInput(input); err != nil { 928 return out, metadata, err 929 } 930 return next.HandleInitialize(ctx, in) 931} 932 933type validateOpDescribePatchGroupState struct { 934} 935 936func (*validateOpDescribePatchGroupState) ID() string { 937 return "OperationInputValidation" 938} 939 940func (m *validateOpDescribePatchGroupState) 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.(*DescribePatchGroupStateInput) 944 if !ok { 945 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 946 } 947 if err := validateOpDescribePatchGroupStateInput(input); err != nil { 948 return out, metadata, err 949 } 950 return next.HandleInitialize(ctx, in) 951} 952 953type validateOpDescribePatchProperties struct { 954} 955 956func (*validateOpDescribePatchProperties) ID() string { 957 return "OperationInputValidation" 958} 959 960func (m *validateOpDescribePatchProperties) 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.(*DescribePatchPropertiesInput) 964 if !ok { 965 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 966 } 967 if err := validateOpDescribePatchPropertiesInput(input); err != nil { 968 return out, metadata, err 969 } 970 return next.HandleInitialize(ctx, in) 971} 972 973type validateOpDescribeSessions struct { 974} 975 976func (*validateOpDescribeSessions) ID() string { 977 return "OperationInputValidation" 978} 979 980func (m *validateOpDescribeSessions) 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.(*DescribeSessionsInput) 984 if !ok { 985 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 986 } 987 if err := validateOpDescribeSessionsInput(input); err != nil { 988 return out, metadata, err 989 } 990 return next.HandleInitialize(ctx, in) 991} 992 993type validateOpGetAutomationExecution struct { 994} 995 996func (*validateOpGetAutomationExecution) ID() string { 997 return "OperationInputValidation" 998} 999 1000func (m *validateOpGetAutomationExecution) 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.(*GetAutomationExecutionInput) 1004 if !ok { 1005 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1006 } 1007 if err := validateOpGetAutomationExecutionInput(input); err != nil { 1008 return out, metadata, err 1009 } 1010 return next.HandleInitialize(ctx, in) 1011} 1012 1013type validateOpGetCalendarState struct { 1014} 1015 1016func (*validateOpGetCalendarState) ID() string { 1017 return "OperationInputValidation" 1018} 1019 1020func (m *validateOpGetCalendarState) 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.(*GetCalendarStateInput) 1024 if !ok { 1025 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1026 } 1027 if err := validateOpGetCalendarStateInput(input); err != nil { 1028 return out, metadata, err 1029 } 1030 return next.HandleInitialize(ctx, in) 1031} 1032 1033type validateOpGetCommandInvocation struct { 1034} 1035 1036func (*validateOpGetCommandInvocation) ID() string { 1037 return "OperationInputValidation" 1038} 1039 1040func (m *validateOpGetCommandInvocation) 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.(*GetCommandInvocationInput) 1044 if !ok { 1045 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1046 } 1047 if err := validateOpGetCommandInvocationInput(input); err != nil { 1048 return out, metadata, err 1049 } 1050 return next.HandleInitialize(ctx, in) 1051} 1052 1053type validateOpGetConnectionStatus struct { 1054} 1055 1056func (*validateOpGetConnectionStatus) ID() string { 1057 return "OperationInputValidation" 1058} 1059 1060func (m *validateOpGetConnectionStatus) 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.(*GetConnectionStatusInput) 1064 if !ok { 1065 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1066 } 1067 if err := validateOpGetConnectionStatusInput(input); err != nil { 1068 return out, metadata, err 1069 } 1070 return next.HandleInitialize(ctx, in) 1071} 1072 1073type validateOpGetDeployablePatchSnapshotForInstance struct { 1074} 1075 1076func (*validateOpGetDeployablePatchSnapshotForInstance) ID() string { 1077 return "OperationInputValidation" 1078} 1079 1080func (m *validateOpGetDeployablePatchSnapshotForInstance) 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.(*GetDeployablePatchSnapshotForInstanceInput) 1084 if !ok { 1085 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1086 } 1087 if err := validateOpGetDeployablePatchSnapshotForInstanceInput(input); err != nil { 1088 return out, metadata, err 1089 } 1090 return next.HandleInitialize(ctx, in) 1091} 1092 1093type validateOpGetDocument struct { 1094} 1095 1096func (*validateOpGetDocument) ID() string { 1097 return "OperationInputValidation" 1098} 1099 1100func (m *validateOpGetDocument) 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.(*GetDocumentInput) 1104 if !ok { 1105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1106 } 1107 if err := validateOpGetDocumentInput(input); err != nil { 1108 return out, metadata, err 1109 } 1110 return next.HandleInitialize(ctx, in) 1111} 1112 1113type validateOpGetInventory struct { 1114} 1115 1116func (*validateOpGetInventory) ID() string { 1117 return "OperationInputValidation" 1118} 1119 1120func (m *validateOpGetInventory) 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.(*GetInventoryInput) 1124 if !ok { 1125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1126 } 1127 if err := validateOpGetInventoryInput(input); err != nil { 1128 return out, metadata, err 1129 } 1130 return next.HandleInitialize(ctx, in) 1131} 1132 1133type validateOpGetMaintenanceWindowExecution struct { 1134} 1135 1136func (*validateOpGetMaintenanceWindowExecution) ID() string { 1137 return "OperationInputValidation" 1138} 1139 1140func (m *validateOpGetMaintenanceWindowExecution) 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.(*GetMaintenanceWindowExecutionInput) 1144 if !ok { 1145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1146 } 1147 if err := validateOpGetMaintenanceWindowExecutionInput(input); err != nil { 1148 return out, metadata, err 1149 } 1150 return next.HandleInitialize(ctx, in) 1151} 1152 1153type validateOpGetMaintenanceWindowExecutionTask struct { 1154} 1155 1156func (*validateOpGetMaintenanceWindowExecutionTask) ID() string { 1157 return "OperationInputValidation" 1158} 1159 1160func (m *validateOpGetMaintenanceWindowExecutionTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1161 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1162) { 1163 input, ok := in.Parameters.(*GetMaintenanceWindowExecutionTaskInput) 1164 if !ok { 1165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1166 } 1167 if err := validateOpGetMaintenanceWindowExecutionTaskInput(input); err != nil { 1168 return out, metadata, err 1169 } 1170 return next.HandleInitialize(ctx, in) 1171} 1172 1173type validateOpGetMaintenanceWindowExecutionTaskInvocation struct { 1174} 1175 1176func (*validateOpGetMaintenanceWindowExecutionTaskInvocation) ID() string { 1177 return "OperationInputValidation" 1178} 1179 1180func (m *validateOpGetMaintenanceWindowExecutionTaskInvocation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1181 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1182) { 1183 input, ok := in.Parameters.(*GetMaintenanceWindowExecutionTaskInvocationInput) 1184 if !ok { 1185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1186 } 1187 if err := validateOpGetMaintenanceWindowExecutionTaskInvocationInput(input); err != nil { 1188 return out, metadata, err 1189 } 1190 return next.HandleInitialize(ctx, in) 1191} 1192 1193type validateOpGetMaintenanceWindow struct { 1194} 1195 1196func (*validateOpGetMaintenanceWindow) ID() string { 1197 return "OperationInputValidation" 1198} 1199 1200func (m *validateOpGetMaintenanceWindow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1201 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1202) { 1203 input, ok := in.Parameters.(*GetMaintenanceWindowInput) 1204 if !ok { 1205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1206 } 1207 if err := validateOpGetMaintenanceWindowInput(input); err != nil { 1208 return out, metadata, err 1209 } 1210 return next.HandleInitialize(ctx, in) 1211} 1212 1213type validateOpGetMaintenanceWindowTask struct { 1214} 1215 1216func (*validateOpGetMaintenanceWindowTask) ID() string { 1217 return "OperationInputValidation" 1218} 1219 1220func (m *validateOpGetMaintenanceWindowTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1221 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1222) { 1223 input, ok := in.Parameters.(*GetMaintenanceWindowTaskInput) 1224 if !ok { 1225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1226 } 1227 if err := validateOpGetMaintenanceWindowTaskInput(input); err != nil { 1228 return out, metadata, err 1229 } 1230 return next.HandleInitialize(ctx, in) 1231} 1232 1233type validateOpGetOpsItem struct { 1234} 1235 1236func (*validateOpGetOpsItem) ID() string { 1237 return "OperationInputValidation" 1238} 1239 1240func (m *validateOpGetOpsItem) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1241 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1242) { 1243 input, ok := in.Parameters.(*GetOpsItemInput) 1244 if !ok { 1245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1246 } 1247 if err := validateOpGetOpsItemInput(input); err != nil { 1248 return out, metadata, err 1249 } 1250 return next.HandleInitialize(ctx, in) 1251} 1252 1253type validateOpGetOpsMetadata struct { 1254} 1255 1256func (*validateOpGetOpsMetadata) ID() string { 1257 return "OperationInputValidation" 1258} 1259 1260func (m *validateOpGetOpsMetadata) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1261 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1262) { 1263 input, ok := in.Parameters.(*GetOpsMetadataInput) 1264 if !ok { 1265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1266 } 1267 if err := validateOpGetOpsMetadataInput(input); err != nil { 1268 return out, metadata, err 1269 } 1270 return next.HandleInitialize(ctx, in) 1271} 1272 1273type validateOpGetOpsSummary struct { 1274} 1275 1276func (*validateOpGetOpsSummary) ID() string { 1277 return "OperationInputValidation" 1278} 1279 1280func (m *validateOpGetOpsSummary) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1281 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1282) { 1283 input, ok := in.Parameters.(*GetOpsSummaryInput) 1284 if !ok { 1285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1286 } 1287 if err := validateOpGetOpsSummaryInput(input); err != nil { 1288 return out, metadata, err 1289 } 1290 return next.HandleInitialize(ctx, in) 1291} 1292 1293type validateOpGetParameterHistory struct { 1294} 1295 1296func (*validateOpGetParameterHistory) ID() string { 1297 return "OperationInputValidation" 1298} 1299 1300func (m *validateOpGetParameterHistory) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1301 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1302) { 1303 input, ok := in.Parameters.(*GetParameterHistoryInput) 1304 if !ok { 1305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1306 } 1307 if err := validateOpGetParameterHistoryInput(input); err != nil { 1308 return out, metadata, err 1309 } 1310 return next.HandleInitialize(ctx, in) 1311} 1312 1313type validateOpGetParameter struct { 1314} 1315 1316func (*validateOpGetParameter) ID() string { 1317 return "OperationInputValidation" 1318} 1319 1320func (m *validateOpGetParameter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1321 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1322) { 1323 input, ok := in.Parameters.(*GetParameterInput) 1324 if !ok { 1325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1326 } 1327 if err := validateOpGetParameterInput(input); err != nil { 1328 return out, metadata, err 1329 } 1330 return next.HandleInitialize(ctx, in) 1331} 1332 1333type validateOpGetParametersByPath struct { 1334} 1335 1336func (*validateOpGetParametersByPath) ID() string { 1337 return "OperationInputValidation" 1338} 1339 1340func (m *validateOpGetParametersByPath) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1341 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1342) { 1343 input, ok := in.Parameters.(*GetParametersByPathInput) 1344 if !ok { 1345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1346 } 1347 if err := validateOpGetParametersByPathInput(input); err != nil { 1348 return out, metadata, err 1349 } 1350 return next.HandleInitialize(ctx, in) 1351} 1352 1353type validateOpGetParameters struct { 1354} 1355 1356func (*validateOpGetParameters) ID() string { 1357 return "OperationInputValidation" 1358} 1359 1360func (m *validateOpGetParameters) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1361 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1362) { 1363 input, ok := in.Parameters.(*GetParametersInput) 1364 if !ok { 1365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1366 } 1367 if err := validateOpGetParametersInput(input); err != nil { 1368 return out, metadata, err 1369 } 1370 return next.HandleInitialize(ctx, in) 1371} 1372 1373type validateOpGetPatchBaselineForPatchGroup struct { 1374} 1375 1376func (*validateOpGetPatchBaselineForPatchGroup) ID() string { 1377 return "OperationInputValidation" 1378} 1379 1380func (m *validateOpGetPatchBaselineForPatchGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1381 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1382) { 1383 input, ok := in.Parameters.(*GetPatchBaselineForPatchGroupInput) 1384 if !ok { 1385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1386 } 1387 if err := validateOpGetPatchBaselineForPatchGroupInput(input); err != nil { 1388 return out, metadata, err 1389 } 1390 return next.HandleInitialize(ctx, in) 1391} 1392 1393type validateOpGetPatchBaseline struct { 1394} 1395 1396func (*validateOpGetPatchBaseline) ID() string { 1397 return "OperationInputValidation" 1398} 1399 1400func (m *validateOpGetPatchBaseline) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1401 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1402) { 1403 input, ok := in.Parameters.(*GetPatchBaselineInput) 1404 if !ok { 1405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1406 } 1407 if err := validateOpGetPatchBaselineInput(input); err != nil { 1408 return out, metadata, err 1409 } 1410 return next.HandleInitialize(ctx, in) 1411} 1412 1413type validateOpGetServiceSetting struct { 1414} 1415 1416func (*validateOpGetServiceSetting) ID() string { 1417 return "OperationInputValidation" 1418} 1419 1420func (m *validateOpGetServiceSetting) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1421 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1422) { 1423 input, ok := in.Parameters.(*GetServiceSettingInput) 1424 if !ok { 1425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1426 } 1427 if err := validateOpGetServiceSettingInput(input); err != nil { 1428 return out, metadata, err 1429 } 1430 return next.HandleInitialize(ctx, in) 1431} 1432 1433type validateOpLabelParameterVersion struct { 1434} 1435 1436func (*validateOpLabelParameterVersion) ID() string { 1437 return "OperationInputValidation" 1438} 1439 1440func (m *validateOpLabelParameterVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1441 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1442) { 1443 input, ok := in.Parameters.(*LabelParameterVersionInput) 1444 if !ok { 1445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1446 } 1447 if err := validateOpLabelParameterVersionInput(input); err != nil { 1448 return out, metadata, err 1449 } 1450 return next.HandleInitialize(ctx, in) 1451} 1452 1453type validateOpListAssociations struct { 1454} 1455 1456func (*validateOpListAssociations) ID() string { 1457 return "OperationInputValidation" 1458} 1459 1460func (m *validateOpListAssociations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1461 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1462) { 1463 input, ok := in.Parameters.(*ListAssociationsInput) 1464 if !ok { 1465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1466 } 1467 if err := validateOpListAssociationsInput(input); err != nil { 1468 return out, metadata, err 1469 } 1470 return next.HandleInitialize(ctx, in) 1471} 1472 1473type validateOpListAssociationVersions struct { 1474} 1475 1476func (*validateOpListAssociationVersions) ID() string { 1477 return "OperationInputValidation" 1478} 1479 1480func (m *validateOpListAssociationVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1481 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1482) { 1483 input, ok := in.Parameters.(*ListAssociationVersionsInput) 1484 if !ok { 1485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1486 } 1487 if err := validateOpListAssociationVersionsInput(input); err != nil { 1488 return out, metadata, err 1489 } 1490 return next.HandleInitialize(ctx, in) 1491} 1492 1493type validateOpListCommandInvocations struct { 1494} 1495 1496func (*validateOpListCommandInvocations) ID() string { 1497 return "OperationInputValidation" 1498} 1499 1500func (m *validateOpListCommandInvocations) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1501 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1502) { 1503 input, ok := in.Parameters.(*ListCommandInvocationsInput) 1504 if !ok { 1505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1506 } 1507 if err := validateOpListCommandInvocationsInput(input); err != nil { 1508 return out, metadata, err 1509 } 1510 return next.HandleInitialize(ctx, in) 1511} 1512 1513type validateOpListCommands struct { 1514} 1515 1516func (*validateOpListCommands) ID() string { 1517 return "OperationInputValidation" 1518} 1519 1520func (m *validateOpListCommands) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1521 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1522) { 1523 input, ok := in.Parameters.(*ListCommandsInput) 1524 if !ok { 1525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1526 } 1527 if err := validateOpListCommandsInput(input); err != nil { 1528 return out, metadata, err 1529 } 1530 return next.HandleInitialize(ctx, in) 1531} 1532 1533type validateOpListDocumentMetadataHistory struct { 1534} 1535 1536func (*validateOpListDocumentMetadataHistory) ID() string { 1537 return "OperationInputValidation" 1538} 1539 1540func (m *validateOpListDocumentMetadataHistory) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1541 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1542) { 1543 input, ok := in.Parameters.(*ListDocumentMetadataHistoryInput) 1544 if !ok { 1545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1546 } 1547 if err := validateOpListDocumentMetadataHistoryInput(input); err != nil { 1548 return out, metadata, err 1549 } 1550 return next.HandleInitialize(ctx, in) 1551} 1552 1553type validateOpListDocuments struct { 1554} 1555 1556func (*validateOpListDocuments) ID() string { 1557 return "OperationInputValidation" 1558} 1559 1560func (m *validateOpListDocuments) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1561 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1562) { 1563 input, ok := in.Parameters.(*ListDocumentsInput) 1564 if !ok { 1565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1566 } 1567 if err := validateOpListDocumentsInput(input); err != nil { 1568 return out, metadata, err 1569 } 1570 return next.HandleInitialize(ctx, in) 1571} 1572 1573type validateOpListDocumentVersions struct { 1574} 1575 1576func (*validateOpListDocumentVersions) ID() string { 1577 return "OperationInputValidation" 1578} 1579 1580func (m *validateOpListDocumentVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1581 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1582) { 1583 input, ok := in.Parameters.(*ListDocumentVersionsInput) 1584 if !ok { 1585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1586 } 1587 if err := validateOpListDocumentVersionsInput(input); err != nil { 1588 return out, metadata, err 1589 } 1590 return next.HandleInitialize(ctx, in) 1591} 1592 1593type validateOpListInventoryEntries struct { 1594} 1595 1596func (*validateOpListInventoryEntries) ID() string { 1597 return "OperationInputValidation" 1598} 1599 1600func (m *validateOpListInventoryEntries) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1601 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1602) { 1603 input, ok := in.Parameters.(*ListInventoryEntriesInput) 1604 if !ok { 1605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1606 } 1607 if err := validateOpListInventoryEntriesInput(input); err != nil { 1608 return out, metadata, err 1609 } 1610 return next.HandleInitialize(ctx, in) 1611} 1612 1613type validateOpListOpsItemEvents struct { 1614} 1615 1616func (*validateOpListOpsItemEvents) ID() string { 1617 return "OperationInputValidation" 1618} 1619 1620func (m *validateOpListOpsItemEvents) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1621 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1622) { 1623 input, ok := in.Parameters.(*ListOpsItemEventsInput) 1624 if !ok { 1625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1626 } 1627 if err := validateOpListOpsItemEventsInput(input); err != nil { 1628 return out, metadata, err 1629 } 1630 return next.HandleInitialize(ctx, in) 1631} 1632 1633type validateOpListOpsMetadata struct { 1634} 1635 1636func (*validateOpListOpsMetadata) ID() string { 1637 return "OperationInputValidation" 1638} 1639 1640func (m *validateOpListOpsMetadata) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1641 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1642) { 1643 input, ok := in.Parameters.(*ListOpsMetadataInput) 1644 if !ok { 1645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1646 } 1647 if err := validateOpListOpsMetadataInput(input); err != nil { 1648 return out, metadata, err 1649 } 1650 return next.HandleInitialize(ctx, in) 1651} 1652 1653type validateOpListTagsForResource struct { 1654} 1655 1656func (*validateOpListTagsForResource) ID() string { 1657 return "OperationInputValidation" 1658} 1659 1660func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1661 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1662) { 1663 input, ok := in.Parameters.(*ListTagsForResourceInput) 1664 if !ok { 1665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1666 } 1667 if err := validateOpListTagsForResourceInput(input); err != nil { 1668 return out, metadata, err 1669 } 1670 return next.HandleInitialize(ctx, in) 1671} 1672 1673type validateOpModifyDocumentPermission struct { 1674} 1675 1676func (*validateOpModifyDocumentPermission) ID() string { 1677 return "OperationInputValidation" 1678} 1679 1680func (m *validateOpModifyDocumentPermission) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1681 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1682) { 1683 input, ok := in.Parameters.(*ModifyDocumentPermissionInput) 1684 if !ok { 1685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1686 } 1687 if err := validateOpModifyDocumentPermissionInput(input); err != nil { 1688 return out, metadata, err 1689 } 1690 return next.HandleInitialize(ctx, in) 1691} 1692 1693type validateOpPutComplianceItems struct { 1694} 1695 1696func (*validateOpPutComplianceItems) ID() string { 1697 return "OperationInputValidation" 1698} 1699 1700func (m *validateOpPutComplianceItems) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1701 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1702) { 1703 input, ok := in.Parameters.(*PutComplianceItemsInput) 1704 if !ok { 1705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1706 } 1707 if err := validateOpPutComplianceItemsInput(input); err != nil { 1708 return out, metadata, err 1709 } 1710 return next.HandleInitialize(ctx, in) 1711} 1712 1713type validateOpPutInventory struct { 1714} 1715 1716func (*validateOpPutInventory) ID() string { 1717 return "OperationInputValidation" 1718} 1719 1720func (m *validateOpPutInventory) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1721 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1722) { 1723 input, ok := in.Parameters.(*PutInventoryInput) 1724 if !ok { 1725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1726 } 1727 if err := validateOpPutInventoryInput(input); err != nil { 1728 return out, metadata, err 1729 } 1730 return next.HandleInitialize(ctx, in) 1731} 1732 1733type validateOpPutParameter struct { 1734} 1735 1736func (*validateOpPutParameter) ID() string { 1737 return "OperationInputValidation" 1738} 1739 1740func (m *validateOpPutParameter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1741 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1742) { 1743 input, ok := in.Parameters.(*PutParameterInput) 1744 if !ok { 1745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1746 } 1747 if err := validateOpPutParameterInput(input); err != nil { 1748 return out, metadata, err 1749 } 1750 return next.HandleInitialize(ctx, in) 1751} 1752 1753type validateOpRegisterDefaultPatchBaseline struct { 1754} 1755 1756func (*validateOpRegisterDefaultPatchBaseline) ID() string { 1757 return "OperationInputValidation" 1758} 1759 1760func (m *validateOpRegisterDefaultPatchBaseline) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1761 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1762) { 1763 input, ok := in.Parameters.(*RegisterDefaultPatchBaselineInput) 1764 if !ok { 1765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1766 } 1767 if err := validateOpRegisterDefaultPatchBaselineInput(input); err != nil { 1768 return out, metadata, err 1769 } 1770 return next.HandleInitialize(ctx, in) 1771} 1772 1773type validateOpRegisterPatchBaselineForPatchGroup struct { 1774} 1775 1776func (*validateOpRegisterPatchBaselineForPatchGroup) ID() string { 1777 return "OperationInputValidation" 1778} 1779 1780func (m *validateOpRegisterPatchBaselineForPatchGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1781 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1782) { 1783 input, ok := in.Parameters.(*RegisterPatchBaselineForPatchGroupInput) 1784 if !ok { 1785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1786 } 1787 if err := validateOpRegisterPatchBaselineForPatchGroupInput(input); err != nil { 1788 return out, metadata, err 1789 } 1790 return next.HandleInitialize(ctx, in) 1791} 1792 1793type validateOpRegisterTargetWithMaintenanceWindow struct { 1794} 1795 1796func (*validateOpRegisterTargetWithMaintenanceWindow) ID() string { 1797 return "OperationInputValidation" 1798} 1799 1800func (m *validateOpRegisterTargetWithMaintenanceWindow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1801 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1802) { 1803 input, ok := in.Parameters.(*RegisterTargetWithMaintenanceWindowInput) 1804 if !ok { 1805 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1806 } 1807 if err := validateOpRegisterTargetWithMaintenanceWindowInput(input); err != nil { 1808 return out, metadata, err 1809 } 1810 return next.HandleInitialize(ctx, in) 1811} 1812 1813type validateOpRegisterTaskWithMaintenanceWindow struct { 1814} 1815 1816func (*validateOpRegisterTaskWithMaintenanceWindow) ID() string { 1817 return "OperationInputValidation" 1818} 1819 1820func (m *validateOpRegisterTaskWithMaintenanceWindow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1821 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1822) { 1823 input, ok := in.Parameters.(*RegisterTaskWithMaintenanceWindowInput) 1824 if !ok { 1825 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1826 } 1827 if err := validateOpRegisterTaskWithMaintenanceWindowInput(input); err != nil { 1828 return out, metadata, err 1829 } 1830 return next.HandleInitialize(ctx, in) 1831} 1832 1833type validateOpRemoveTagsFromResource struct { 1834} 1835 1836func (*validateOpRemoveTagsFromResource) ID() string { 1837 return "OperationInputValidation" 1838} 1839 1840func (m *validateOpRemoveTagsFromResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1841 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1842) { 1843 input, ok := in.Parameters.(*RemoveTagsFromResourceInput) 1844 if !ok { 1845 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1846 } 1847 if err := validateOpRemoveTagsFromResourceInput(input); err != nil { 1848 return out, metadata, err 1849 } 1850 return next.HandleInitialize(ctx, in) 1851} 1852 1853type validateOpResetServiceSetting struct { 1854} 1855 1856func (*validateOpResetServiceSetting) ID() string { 1857 return "OperationInputValidation" 1858} 1859 1860func (m *validateOpResetServiceSetting) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1861 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1862) { 1863 input, ok := in.Parameters.(*ResetServiceSettingInput) 1864 if !ok { 1865 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1866 } 1867 if err := validateOpResetServiceSettingInput(input); err != nil { 1868 return out, metadata, err 1869 } 1870 return next.HandleInitialize(ctx, in) 1871} 1872 1873type validateOpResumeSession struct { 1874} 1875 1876func (*validateOpResumeSession) ID() string { 1877 return "OperationInputValidation" 1878} 1879 1880func (m *validateOpResumeSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1881 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1882) { 1883 input, ok := in.Parameters.(*ResumeSessionInput) 1884 if !ok { 1885 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1886 } 1887 if err := validateOpResumeSessionInput(input); err != nil { 1888 return out, metadata, err 1889 } 1890 return next.HandleInitialize(ctx, in) 1891} 1892 1893type validateOpSendAutomationSignal struct { 1894} 1895 1896func (*validateOpSendAutomationSignal) ID() string { 1897 return "OperationInputValidation" 1898} 1899 1900func (m *validateOpSendAutomationSignal) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1901 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1902) { 1903 input, ok := in.Parameters.(*SendAutomationSignalInput) 1904 if !ok { 1905 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1906 } 1907 if err := validateOpSendAutomationSignalInput(input); err != nil { 1908 return out, metadata, err 1909 } 1910 return next.HandleInitialize(ctx, in) 1911} 1912 1913type validateOpSendCommand struct { 1914} 1915 1916func (*validateOpSendCommand) ID() string { 1917 return "OperationInputValidation" 1918} 1919 1920func (m *validateOpSendCommand) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1921 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1922) { 1923 input, ok := in.Parameters.(*SendCommandInput) 1924 if !ok { 1925 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1926 } 1927 if err := validateOpSendCommandInput(input); err != nil { 1928 return out, metadata, err 1929 } 1930 return next.HandleInitialize(ctx, in) 1931} 1932 1933type validateOpStartAssociationsOnce struct { 1934} 1935 1936func (*validateOpStartAssociationsOnce) ID() string { 1937 return "OperationInputValidation" 1938} 1939 1940func (m *validateOpStartAssociationsOnce) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1941 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1942) { 1943 input, ok := in.Parameters.(*StartAssociationsOnceInput) 1944 if !ok { 1945 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1946 } 1947 if err := validateOpStartAssociationsOnceInput(input); err != nil { 1948 return out, metadata, err 1949 } 1950 return next.HandleInitialize(ctx, in) 1951} 1952 1953type validateOpStartAutomationExecution struct { 1954} 1955 1956func (*validateOpStartAutomationExecution) ID() string { 1957 return "OperationInputValidation" 1958} 1959 1960func (m *validateOpStartAutomationExecution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1961 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1962) { 1963 input, ok := in.Parameters.(*StartAutomationExecutionInput) 1964 if !ok { 1965 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1966 } 1967 if err := validateOpStartAutomationExecutionInput(input); err != nil { 1968 return out, metadata, err 1969 } 1970 return next.HandleInitialize(ctx, in) 1971} 1972 1973type validateOpStartChangeRequestExecution struct { 1974} 1975 1976func (*validateOpStartChangeRequestExecution) ID() string { 1977 return "OperationInputValidation" 1978} 1979 1980func (m *validateOpStartChangeRequestExecution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1981 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1982) { 1983 input, ok := in.Parameters.(*StartChangeRequestExecutionInput) 1984 if !ok { 1985 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1986 } 1987 if err := validateOpStartChangeRequestExecutionInput(input); err != nil { 1988 return out, metadata, err 1989 } 1990 return next.HandleInitialize(ctx, in) 1991} 1992 1993type validateOpStartSession struct { 1994} 1995 1996func (*validateOpStartSession) ID() string { 1997 return "OperationInputValidation" 1998} 1999 2000func (m *validateOpStartSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2001 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2002) { 2003 input, ok := in.Parameters.(*StartSessionInput) 2004 if !ok { 2005 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2006 } 2007 if err := validateOpStartSessionInput(input); err != nil { 2008 return out, metadata, err 2009 } 2010 return next.HandleInitialize(ctx, in) 2011} 2012 2013type validateOpStopAutomationExecution struct { 2014} 2015 2016func (*validateOpStopAutomationExecution) ID() string { 2017 return "OperationInputValidation" 2018} 2019 2020func (m *validateOpStopAutomationExecution) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2021 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2022) { 2023 input, ok := in.Parameters.(*StopAutomationExecutionInput) 2024 if !ok { 2025 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2026 } 2027 if err := validateOpStopAutomationExecutionInput(input); err != nil { 2028 return out, metadata, err 2029 } 2030 return next.HandleInitialize(ctx, in) 2031} 2032 2033type validateOpTerminateSession struct { 2034} 2035 2036func (*validateOpTerminateSession) ID() string { 2037 return "OperationInputValidation" 2038} 2039 2040func (m *validateOpTerminateSession) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2041 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2042) { 2043 input, ok := in.Parameters.(*TerminateSessionInput) 2044 if !ok { 2045 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2046 } 2047 if err := validateOpTerminateSessionInput(input); err != nil { 2048 return out, metadata, err 2049 } 2050 return next.HandleInitialize(ctx, in) 2051} 2052 2053type validateOpUpdateAssociation struct { 2054} 2055 2056func (*validateOpUpdateAssociation) ID() string { 2057 return "OperationInputValidation" 2058} 2059 2060func (m *validateOpUpdateAssociation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2061 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2062) { 2063 input, ok := in.Parameters.(*UpdateAssociationInput) 2064 if !ok { 2065 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2066 } 2067 if err := validateOpUpdateAssociationInput(input); err != nil { 2068 return out, metadata, err 2069 } 2070 return next.HandleInitialize(ctx, in) 2071} 2072 2073type validateOpUpdateAssociationStatus struct { 2074} 2075 2076func (*validateOpUpdateAssociationStatus) ID() string { 2077 return "OperationInputValidation" 2078} 2079 2080func (m *validateOpUpdateAssociationStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2081 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2082) { 2083 input, ok := in.Parameters.(*UpdateAssociationStatusInput) 2084 if !ok { 2085 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2086 } 2087 if err := validateOpUpdateAssociationStatusInput(input); err != nil { 2088 return out, metadata, err 2089 } 2090 return next.HandleInitialize(ctx, in) 2091} 2092 2093type validateOpUpdateDocumentDefaultVersion struct { 2094} 2095 2096func (*validateOpUpdateDocumentDefaultVersion) ID() string { 2097 return "OperationInputValidation" 2098} 2099 2100func (m *validateOpUpdateDocumentDefaultVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2101 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2102) { 2103 input, ok := in.Parameters.(*UpdateDocumentDefaultVersionInput) 2104 if !ok { 2105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2106 } 2107 if err := validateOpUpdateDocumentDefaultVersionInput(input); err != nil { 2108 return out, metadata, err 2109 } 2110 return next.HandleInitialize(ctx, in) 2111} 2112 2113type validateOpUpdateDocument struct { 2114} 2115 2116func (*validateOpUpdateDocument) ID() string { 2117 return "OperationInputValidation" 2118} 2119 2120func (m *validateOpUpdateDocument) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2121 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2122) { 2123 input, ok := in.Parameters.(*UpdateDocumentInput) 2124 if !ok { 2125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2126 } 2127 if err := validateOpUpdateDocumentInput(input); err != nil { 2128 return out, metadata, err 2129 } 2130 return next.HandleInitialize(ctx, in) 2131} 2132 2133type validateOpUpdateDocumentMetadata struct { 2134} 2135 2136func (*validateOpUpdateDocumentMetadata) ID() string { 2137 return "OperationInputValidation" 2138} 2139 2140func (m *validateOpUpdateDocumentMetadata) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2141 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2142) { 2143 input, ok := in.Parameters.(*UpdateDocumentMetadataInput) 2144 if !ok { 2145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2146 } 2147 if err := validateOpUpdateDocumentMetadataInput(input); err != nil { 2148 return out, metadata, err 2149 } 2150 return next.HandleInitialize(ctx, in) 2151} 2152 2153type validateOpUpdateMaintenanceWindow struct { 2154} 2155 2156func (*validateOpUpdateMaintenanceWindow) ID() string { 2157 return "OperationInputValidation" 2158} 2159 2160func (m *validateOpUpdateMaintenanceWindow) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2161 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2162) { 2163 input, ok := in.Parameters.(*UpdateMaintenanceWindowInput) 2164 if !ok { 2165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2166 } 2167 if err := validateOpUpdateMaintenanceWindowInput(input); err != nil { 2168 return out, metadata, err 2169 } 2170 return next.HandleInitialize(ctx, in) 2171} 2172 2173type validateOpUpdateMaintenanceWindowTarget struct { 2174} 2175 2176func (*validateOpUpdateMaintenanceWindowTarget) ID() string { 2177 return "OperationInputValidation" 2178} 2179 2180func (m *validateOpUpdateMaintenanceWindowTarget) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2181 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2182) { 2183 input, ok := in.Parameters.(*UpdateMaintenanceWindowTargetInput) 2184 if !ok { 2185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2186 } 2187 if err := validateOpUpdateMaintenanceWindowTargetInput(input); err != nil { 2188 return out, metadata, err 2189 } 2190 return next.HandleInitialize(ctx, in) 2191} 2192 2193type validateOpUpdateMaintenanceWindowTask struct { 2194} 2195 2196func (*validateOpUpdateMaintenanceWindowTask) ID() string { 2197 return "OperationInputValidation" 2198} 2199 2200func (m *validateOpUpdateMaintenanceWindowTask) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2201 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2202) { 2203 input, ok := in.Parameters.(*UpdateMaintenanceWindowTaskInput) 2204 if !ok { 2205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2206 } 2207 if err := validateOpUpdateMaintenanceWindowTaskInput(input); err != nil { 2208 return out, metadata, err 2209 } 2210 return next.HandleInitialize(ctx, in) 2211} 2212 2213type validateOpUpdateManagedInstanceRole struct { 2214} 2215 2216func (*validateOpUpdateManagedInstanceRole) ID() string { 2217 return "OperationInputValidation" 2218} 2219 2220func (m *validateOpUpdateManagedInstanceRole) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2221 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2222) { 2223 input, ok := in.Parameters.(*UpdateManagedInstanceRoleInput) 2224 if !ok { 2225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2226 } 2227 if err := validateOpUpdateManagedInstanceRoleInput(input); err != nil { 2228 return out, metadata, err 2229 } 2230 return next.HandleInitialize(ctx, in) 2231} 2232 2233type validateOpUpdateOpsItem struct { 2234} 2235 2236func (*validateOpUpdateOpsItem) ID() string { 2237 return "OperationInputValidation" 2238} 2239 2240func (m *validateOpUpdateOpsItem) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2241 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2242) { 2243 input, ok := in.Parameters.(*UpdateOpsItemInput) 2244 if !ok { 2245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2246 } 2247 if err := validateOpUpdateOpsItemInput(input); err != nil { 2248 return out, metadata, err 2249 } 2250 return next.HandleInitialize(ctx, in) 2251} 2252 2253type validateOpUpdateOpsMetadata struct { 2254} 2255 2256func (*validateOpUpdateOpsMetadata) ID() string { 2257 return "OperationInputValidation" 2258} 2259 2260func (m *validateOpUpdateOpsMetadata) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2261 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2262) { 2263 input, ok := in.Parameters.(*UpdateOpsMetadataInput) 2264 if !ok { 2265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2266 } 2267 if err := validateOpUpdateOpsMetadataInput(input); err != nil { 2268 return out, metadata, err 2269 } 2270 return next.HandleInitialize(ctx, in) 2271} 2272 2273type validateOpUpdatePatchBaseline struct { 2274} 2275 2276func (*validateOpUpdatePatchBaseline) ID() string { 2277 return "OperationInputValidation" 2278} 2279 2280func (m *validateOpUpdatePatchBaseline) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2281 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2282) { 2283 input, ok := in.Parameters.(*UpdatePatchBaselineInput) 2284 if !ok { 2285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2286 } 2287 if err := validateOpUpdatePatchBaselineInput(input); err != nil { 2288 return out, metadata, err 2289 } 2290 return next.HandleInitialize(ctx, in) 2291} 2292 2293type validateOpUpdateResourceDataSync struct { 2294} 2295 2296func (*validateOpUpdateResourceDataSync) ID() string { 2297 return "OperationInputValidation" 2298} 2299 2300func (m *validateOpUpdateResourceDataSync) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2301 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2302) { 2303 input, ok := in.Parameters.(*UpdateResourceDataSyncInput) 2304 if !ok { 2305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2306 } 2307 if err := validateOpUpdateResourceDataSyncInput(input); err != nil { 2308 return out, metadata, err 2309 } 2310 return next.HandleInitialize(ctx, in) 2311} 2312 2313type validateOpUpdateServiceSetting struct { 2314} 2315 2316func (*validateOpUpdateServiceSetting) ID() string { 2317 return "OperationInputValidation" 2318} 2319 2320func (m *validateOpUpdateServiceSetting) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2321 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2322) { 2323 input, ok := in.Parameters.(*UpdateServiceSettingInput) 2324 if !ok { 2325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2326 } 2327 if err := validateOpUpdateServiceSettingInput(input); err != nil { 2328 return out, metadata, err 2329 } 2330 return next.HandleInitialize(ctx, in) 2331} 2332 2333func addOpAddTagsToResourceValidationMiddleware(stack *middleware.Stack) error { 2334 return stack.Initialize.Add(&validateOpAddTagsToResource{}, middleware.After) 2335} 2336 2337func addOpCancelCommandValidationMiddleware(stack *middleware.Stack) error { 2338 return stack.Initialize.Add(&validateOpCancelCommand{}, middleware.After) 2339} 2340 2341func addOpCancelMaintenanceWindowExecutionValidationMiddleware(stack *middleware.Stack) error { 2342 return stack.Initialize.Add(&validateOpCancelMaintenanceWindowExecution{}, middleware.After) 2343} 2344 2345func addOpCreateActivationValidationMiddleware(stack *middleware.Stack) error { 2346 return stack.Initialize.Add(&validateOpCreateActivation{}, middleware.After) 2347} 2348 2349func addOpCreateAssociationBatchValidationMiddleware(stack *middleware.Stack) error { 2350 return stack.Initialize.Add(&validateOpCreateAssociationBatch{}, middleware.After) 2351} 2352 2353func addOpCreateAssociationValidationMiddleware(stack *middleware.Stack) error { 2354 return stack.Initialize.Add(&validateOpCreateAssociation{}, middleware.After) 2355} 2356 2357func addOpCreateDocumentValidationMiddleware(stack *middleware.Stack) error { 2358 return stack.Initialize.Add(&validateOpCreateDocument{}, middleware.After) 2359} 2360 2361func addOpCreateMaintenanceWindowValidationMiddleware(stack *middleware.Stack) error { 2362 return stack.Initialize.Add(&validateOpCreateMaintenanceWindow{}, middleware.After) 2363} 2364 2365func addOpCreateOpsItemValidationMiddleware(stack *middleware.Stack) error { 2366 return stack.Initialize.Add(&validateOpCreateOpsItem{}, middleware.After) 2367} 2368 2369func addOpCreateOpsMetadataValidationMiddleware(stack *middleware.Stack) error { 2370 return stack.Initialize.Add(&validateOpCreateOpsMetadata{}, middleware.After) 2371} 2372 2373func addOpCreatePatchBaselineValidationMiddleware(stack *middleware.Stack) error { 2374 return stack.Initialize.Add(&validateOpCreatePatchBaseline{}, middleware.After) 2375} 2376 2377func addOpCreateResourceDataSyncValidationMiddleware(stack *middleware.Stack) error { 2378 return stack.Initialize.Add(&validateOpCreateResourceDataSync{}, middleware.After) 2379} 2380 2381func addOpDeleteActivationValidationMiddleware(stack *middleware.Stack) error { 2382 return stack.Initialize.Add(&validateOpDeleteActivation{}, middleware.After) 2383} 2384 2385func addOpDeleteDocumentValidationMiddleware(stack *middleware.Stack) error { 2386 return stack.Initialize.Add(&validateOpDeleteDocument{}, middleware.After) 2387} 2388 2389func addOpDeleteInventoryValidationMiddleware(stack *middleware.Stack) error { 2390 return stack.Initialize.Add(&validateOpDeleteInventory{}, middleware.After) 2391} 2392 2393func addOpDeleteMaintenanceWindowValidationMiddleware(stack *middleware.Stack) error { 2394 return stack.Initialize.Add(&validateOpDeleteMaintenanceWindow{}, middleware.After) 2395} 2396 2397func addOpDeleteOpsMetadataValidationMiddleware(stack *middleware.Stack) error { 2398 return stack.Initialize.Add(&validateOpDeleteOpsMetadata{}, middleware.After) 2399} 2400 2401func addOpDeleteParameterValidationMiddleware(stack *middleware.Stack) error { 2402 return stack.Initialize.Add(&validateOpDeleteParameter{}, middleware.After) 2403} 2404 2405func addOpDeleteParametersValidationMiddleware(stack *middleware.Stack) error { 2406 return stack.Initialize.Add(&validateOpDeleteParameters{}, middleware.After) 2407} 2408 2409func addOpDeletePatchBaselineValidationMiddleware(stack *middleware.Stack) error { 2410 return stack.Initialize.Add(&validateOpDeletePatchBaseline{}, middleware.After) 2411} 2412 2413func addOpDeleteResourceDataSyncValidationMiddleware(stack *middleware.Stack) error { 2414 return stack.Initialize.Add(&validateOpDeleteResourceDataSync{}, middleware.After) 2415} 2416 2417func addOpDeregisterManagedInstanceValidationMiddleware(stack *middleware.Stack) error { 2418 return stack.Initialize.Add(&validateOpDeregisterManagedInstance{}, middleware.After) 2419} 2420 2421func addOpDeregisterPatchBaselineForPatchGroupValidationMiddleware(stack *middleware.Stack) error { 2422 return stack.Initialize.Add(&validateOpDeregisterPatchBaselineForPatchGroup{}, middleware.After) 2423} 2424 2425func addOpDeregisterTargetFromMaintenanceWindowValidationMiddleware(stack *middleware.Stack) error { 2426 return stack.Initialize.Add(&validateOpDeregisterTargetFromMaintenanceWindow{}, middleware.After) 2427} 2428 2429func addOpDeregisterTaskFromMaintenanceWindowValidationMiddleware(stack *middleware.Stack) error { 2430 return stack.Initialize.Add(&validateOpDeregisterTaskFromMaintenanceWindow{}, middleware.After) 2431} 2432 2433func addOpDescribeAssociationExecutionsValidationMiddleware(stack *middleware.Stack) error { 2434 return stack.Initialize.Add(&validateOpDescribeAssociationExecutions{}, middleware.After) 2435} 2436 2437func addOpDescribeAssociationExecutionTargetsValidationMiddleware(stack *middleware.Stack) error { 2438 return stack.Initialize.Add(&validateOpDescribeAssociationExecutionTargets{}, middleware.After) 2439} 2440 2441func addOpDescribeAutomationExecutionsValidationMiddleware(stack *middleware.Stack) error { 2442 return stack.Initialize.Add(&validateOpDescribeAutomationExecutions{}, middleware.After) 2443} 2444 2445func addOpDescribeAutomationStepExecutionsValidationMiddleware(stack *middleware.Stack) error { 2446 return stack.Initialize.Add(&validateOpDescribeAutomationStepExecutions{}, middleware.After) 2447} 2448 2449func addOpDescribeDocumentValidationMiddleware(stack *middleware.Stack) error { 2450 return stack.Initialize.Add(&validateOpDescribeDocument{}, middleware.After) 2451} 2452 2453func addOpDescribeDocumentPermissionValidationMiddleware(stack *middleware.Stack) error { 2454 return stack.Initialize.Add(&validateOpDescribeDocumentPermission{}, middleware.After) 2455} 2456 2457func addOpDescribeEffectiveInstanceAssociationsValidationMiddleware(stack *middleware.Stack) error { 2458 return stack.Initialize.Add(&validateOpDescribeEffectiveInstanceAssociations{}, middleware.After) 2459} 2460 2461func addOpDescribeEffectivePatchesForPatchBaselineValidationMiddleware(stack *middleware.Stack) error { 2462 return stack.Initialize.Add(&validateOpDescribeEffectivePatchesForPatchBaseline{}, middleware.After) 2463} 2464 2465func addOpDescribeInstanceAssociationsStatusValidationMiddleware(stack *middleware.Stack) error { 2466 return stack.Initialize.Add(&validateOpDescribeInstanceAssociationsStatus{}, middleware.After) 2467} 2468 2469func addOpDescribeInstanceInformationValidationMiddleware(stack *middleware.Stack) error { 2470 return stack.Initialize.Add(&validateOpDescribeInstanceInformation{}, middleware.After) 2471} 2472 2473func addOpDescribeInstancePatchesValidationMiddleware(stack *middleware.Stack) error { 2474 return stack.Initialize.Add(&validateOpDescribeInstancePatches{}, middleware.After) 2475} 2476 2477func addOpDescribeInstancePatchStatesForPatchGroupValidationMiddleware(stack *middleware.Stack) error { 2478 return stack.Initialize.Add(&validateOpDescribeInstancePatchStatesForPatchGroup{}, middleware.After) 2479} 2480 2481func addOpDescribeInstancePatchStatesValidationMiddleware(stack *middleware.Stack) error { 2482 return stack.Initialize.Add(&validateOpDescribeInstancePatchStates{}, middleware.After) 2483} 2484 2485func addOpDescribeMaintenanceWindowExecutionsValidationMiddleware(stack *middleware.Stack) error { 2486 return stack.Initialize.Add(&validateOpDescribeMaintenanceWindowExecutions{}, middleware.After) 2487} 2488 2489func addOpDescribeMaintenanceWindowExecutionTaskInvocationsValidationMiddleware(stack *middleware.Stack) error { 2490 return stack.Initialize.Add(&validateOpDescribeMaintenanceWindowExecutionTaskInvocations{}, middleware.After) 2491} 2492 2493func addOpDescribeMaintenanceWindowExecutionTasksValidationMiddleware(stack *middleware.Stack) error { 2494 return stack.Initialize.Add(&validateOpDescribeMaintenanceWindowExecutionTasks{}, middleware.After) 2495} 2496 2497func addOpDescribeMaintenanceWindowsForTargetValidationMiddleware(stack *middleware.Stack) error { 2498 return stack.Initialize.Add(&validateOpDescribeMaintenanceWindowsForTarget{}, middleware.After) 2499} 2500 2501func addOpDescribeMaintenanceWindowTargetsValidationMiddleware(stack *middleware.Stack) error { 2502 return stack.Initialize.Add(&validateOpDescribeMaintenanceWindowTargets{}, middleware.After) 2503} 2504 2505func addOpDescribeMaintenanceWindowTasksValidationMiddleware(stack *middleware.Stack) error { 2506 return stack.Initialize.Add(&validateOpDescribeMaintenanceWindowTasks{}, middleware.After) 2507} 2508 2509func addOpDescribeOpsItemsValidationMiddleware(stack *middleware.Stack) error { 2510 return stack.Initialize.Add(&validateOpDescribeOpsItems{}, middleware.After) 2511} 2512 2513func addOpDescribeParametersValidationMiddleware(stack *middleware.Stack) error { 2514 return stack.Initialize.Add(&validateOpDescribeParameters{}, middleware.After) 2515} 2516 2517func addOpDescribePatchGroupStateValidationMiddleware(stack *middleware.Stack) error { 2518 return stack.Initialize.Add(&validateOpDescribePatchGroupState{}, middleware.After) 2519} 2520 2521func addOpDescribePatchPropertiesValidationMiddleware(stack *middleware.Stack) error { 2522 return stack.Initialize.Add(&validateOpDescribePatchProperties{}, middleware.After) 2523} 2524 2525func addOpDescribeSessionsValidationMiddleware(stack *middleware.Stack) error { 2526 return stack.Initialize.Add(&validateOpDescribeSessions{}, middleware.After) 2527} 2528 2529func addOpGetAutomationExecutionValidationMiddleware(stack *middleware.Stack) error { 2530 return stack.Initialize.Add(&validateOpGetAutomationExecution{}, middleware.After) 2531} 2532 2533func addOpGetCalendarStateValidationMiddleware(stack *middleware.Stack) error { 2534 return stack.Initialize.Add(&validateOpGetCalendarState{}, middleware.After) 2535} 2536 2537func addOpGetCommandInvocationValidationMiddleware(stack *middleware.Stack) error { 2538 return stack.Initialize.Add(&validateOpGetCommandInvocation{}, middleware.After) 2539} 2540 2541func addOpGetConnectionStatusValidationMiddleware(stack *middleware.Stack) error { 2542 return stack.Initialize.Add(&validateOpGetConnectionStatus{}, middleware.After) 2543} 2544 2545func addOpGetDeployablePatchSnapshotForInstanceValidationMiddleware(stack *middleware.Stack) error { 2546 return stack.Initialize.Add(&validateOpGetDeployablePatchSnapshotForInstance{}, middleware.After) 2547} 2548 2549func addOpGetDocumentValidationMiddleware(stack *middleware.Stack) error { 2550 return stack.Initialize.Add(&validateOpGetDocument{}, middleware.After) 2551} 2552 2553func addOpGetInventoryValidationMiddleware(stack *middleware.Stack) error { 2554 return stack.Initialize.Add(&validateOpGetInventory{}, middleware.After) 2555} 2556 2557func addOpGetMaintenanceWindowExecutionValidationMiddleware(stack *middleware.Stack) error { 2558 return stack.Initialize.Add(&validateOpGetMaintenanceWindowExecution{}, middleware.After) 2559} 2560 2561func addOpGetMaintenanceWindowExecutionTaskValidationMiddleware(stack *middleware.Stack) error { 2562 return stack.Initialize.Add(&validateOpGetMaintenanceWindowExecutionTask{}, middleware.After) 2563} 2564 2565func addOpGetMaintenanceWindowExecutionTaskInvocationValidationMiddleware(stack *middleware.Stack) error { 2566 return stack.Initialize.Add(&validateOpGetMaintenanceWindowExecutionTaskInvocation{}, middleware.After) 2567} 2568 2569func addOpGetMaintenanceWindowValidationMiddleware(stack *middleware.Stack) error { 2570 return stack.Initialize.Add(&validateOpGetMaintenanceWindow{}, middleware.After) 2571} 2572 2573func addOpGetMaintenanceWindowTaskValidationMiddleware(stack *middleware.Stack) error { 2574 return stack.Initialize.Add(&validateOpGetMaintenanceWindowTask{}, middleware.After) 2575} 2576 2577func addOpGetOpsItemValidationMiddleware(stack *middleware.Stack) error { 2578 return stack.Initialize.Add(&validateOpGetOpsItem{}, middleware.After) 2579} 2580 2581func addOpGetOpsMetadataValidationMiddleware(stack *middleware.Stack) error { 2582 return stack.Initialize.Add(&validateOpGetOpsMetadata{}, middleware.After) 2583} 2584 2585func addOpGetOpsSummaryValidationMiddleware(stack *middleware.Stack) error { 2586 return stack.Initialize.Add(&validateOpGetOpsSummary{}, middleware.After) 2587} 2588 2589func addOpGetParameterHistoryValidationMiddleware(stack *middleware.Stack) error { 2590 return stack.Initialize.Add(&validateOpGetParameterHistory{}, middleware.After) 2591} 2592 2593func addOpGetParameterValidationMiddleware(stack *middleware.Stack) error { 2594 return stack.Initialize.Add(&validateOpGetParameter{}, middleware.After) 2595} 2596 2597func addOpGetParametersByPathValidationMiddleware(stack *middleware.Stack) error { 2598 return stack.Initialize.Add(&validateOpGetParametersByPath{}, middleware.After) 2599} 2600 2601func addOpGetParametersValidationMiddleware(stack *middleware.Stack) error { 2602 return stack.Initialize.Add(&validateOpGetParameters{}, middleware.After) 2603} 2604 2605func addOpGetPatchBaselineForPatchGroupValidationMiddleware(stack *middleware.Stack) error { 2606 return stack.Initialize.Add(&validateOpGetPatchBaselineForPatchGroup{}, middleware.After) 2607} 2608 2609func addOpGetPatchBaselineValidationMiddleware(stack *middleware.Stack) error { 2610 return stack.Initialize.Add(&validateOpGetPatchBaseline{}, middleware.After) 2611} 2612 2613func addOpGetServiceSettingValidationMiddleware(stack *middleware.Stack) error { 2614 return stack.Initialize.Add(&validateOpGetServiceSetting{}, middleware.After) 2615} 2616 2617func addOpLabelParameterVersionValidationMiddleware(stack *middleware.Stack) error { 2618 return stack.Initialize.Add(&validateOpLabelParameterVersion{}, middleware.After) 2619} 2620 2621func addOpListAssociationsValidationMiddleware(stack *middleware.Stack) error { 2622 return stack.Initialize.Add(&validateOpListAssociations{}, middleware.After) 2623} 2624 2625func addOpListAssociationVersionsValidationMiddleware(stack *middleware.Stack) error { 2626 return stack.Initialize.Add(&validateOpListAssociationVersions{}, middleware.After) 2627} 2628 2629func addOpListCommandInvocationsValidationMiddleware(stack *middleware.Stack) error { 2630 return stack.Initialize.Add(&validateOpListCommandInvocations{}, middleware.After) 2631} 2632 2633func addOpListCommandsValidationMiddleware(stack *middleware.Stack) error { 2634 return stack.Initialize.Add(&validateOpListCommands{}, middleware.After) 2635} 2636 2637func addOpListDocumentMetadataHistoryValidationMiddleware(stack *middleware.Stack) error { 2638 return stack.Initialize.Add(&validateOpListDocumentMetadataHistory{}, middleware.After) 2639} 2640 2641func addOpListDocumentsValidationMiddleware(stack *middleware.Stack) error { 2642 return stack.Initialize.Add(&validateOpListDocuments{}, middleware.After) 2643} 2644 2645func addOpListDocumentVersionsValidationMiddleware(stack *middleware.Stack) error { 2646 return stack.Initialize.Add(&validateOpListDocumentVersions{}, middleware.After) 2647} 2648 2649func addOpListInventoryEntriesValidationMiddleware(stack *middleware.Stack) error { 2650 return stack.Initialize.Add(&validateOpListInventoryEntries{}, middleware.After) 2651} 2652 2653func addOpListOpsItemEventsValidationMiddleware(stack *middleware.Stack) error { 2654 return stack.Initialize.Add(&validateOpListOpsItemEvents{}, middleware.After) 2655} 2656 2657func addOpListOpsMetadataValidationMiddleware(stack *middleware.Stack) error { 2658 return stack.Initialize.Add(&validateOpListOpsMetadata{}, middleware.After) 2659} 2660 2661func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 2662 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 2663} 2664 2665func addOpModifyDocumentPermissionValidationMiddleware(stack *middleware.Stack) error { 2666 return stack.Initialize.Add(&validateOpModifyDocumentPermission{}, middleware.After) 2667} 2668 2669func addOpPutComplianceItemsValidationMiddleware(stack *middleware.Stack) error { 2670 return stack.Initialize.Add(&validateOpPutComplianceItems{}, middleware.After) 2671} 2672 2673func addOpPutInventoryValidationMiddleware(stack *middleware.Stack) error { 2674 return stack.Initialize.Add(&validateOpPutInventory{}, middleware.After) 2675} 2676 2677func addOpPutParameterValidationMiddleware(stack *middleware.Stack) error { 2678 return stack.Initialize.Add(&validateOpPutParameter{}, middleware.After) 2679} 2680 2681func addOpRegisterDefaultPatchBaselineValidationMiddleware(stack *middleware.Stack) error { 2682 return stack.Initialize.Add(&validateOpRegisterDefaultPatchBaseline{}, middleware.After) 2683} 2684 2685func addOpRegisterPatchBaselineForPatchGroupValidationMiddleware(stack *middleware.Stack) error { 2686 return stack.Initialize.Add(&validateOpRegisterPatchBaselineForPatchGroup{}, middleware.After) 2687} 2688 2689func addOpRegisterTargetWithMaintenanceWindowValidationMiddleware(stack *middleware.Stack) error { 2690 return stack.Initialize.Add(&validateOpRegisterTargetWithMaintenanceWindow{}, middleware.After) 2691} 2692 2693func addOpRegisterTaskWithMaintenanceWindowValidationMiddleware(stack *middleware.Stack) error { 2694 return stack.Initialize.Add(&validateOpRegisterTaskWithMaintenanceWindow{}, middleware.After) 2695} 2696 2697func addOpRemoveTagsFromResourceValidationMiddleware(stack *middleware.Stack) error { 2698 return stack.Initialize.Add(&validateOpRemoveTagsFromResource{}, middleware.After) 2699} 2700 2701func addOpResetServiceSettingValidationMiddleware(stack *middleware.Stack) error { 2702 return stack.Initialize.Add(&validateOpResetServiceSetting{}, middleware.After) 2703} 2704 2705func addOpResumeSessionValidationMiddleware(stack *middleware.Stack) error { 2706 return stack.Initialize.Add(&validateOpResumeSession{}, middleware.After) 2707} 2708 2709func addOpSendAutomationSignalValidationMiddleware(stack *middleware.Stack) error { 2710 return stack.Initialize.Add(&validateOpSendAutomationSignal{}, middleware.After) 2711} 2712 2713func addOpSendCommandValidationMiddleware(stack *middleware.Stack) error { 2714 return stack.Initialize.Add(&validateOpSendCommand{}, middleware.After) 2715} 2716 2717func addOpStartAssociationsOnceValidationMiddleware(stack *middleware.Stack) error { 2718 return stack.Initialize.Add(&validateOpStartAssociationsOnce{}, middleware.After) 2719} 2720 2721func addOpStartAutomationExecutionValidationMiddleware(stack *middleware.Stack) error { 2722 return stack.Initialize.Add(&validateOpStartAutomationExecution{}, middleware.After) 2723} 2724 2725func addOpStartChangeRequestExecutionValidationMiddleware(stack *middleware.Stack) error { 2726 return stack.Initialize.Add(&validateOpStartChangeRequestExecution{}, middleware.After) 2727} 2728 2729func addOpStartSessionValidationMiddleware(stack *middleware.Stack) error { 2730 return stack.Initialize.Add(&validateOpStartSession{}, middleware.After) 2731} 2732 2733func addOpStopAutomationExecutionValidationMiddleware(stack *middleware.Stack) error { 2734 return stack.Initialize.Add(&validateOpStopAutomationExecution{}, middleware.After) 2735} 2736 2737func addOpTerminateSessionValidationMiddleware(stack *middleware.Stack) error { 2738 return stack.Initialize.Add(&validateOpTerminateSession{}, middleware.After) 2739} 2740 2741func addOpUpdateAssociationValidationMiddleware(stack *middleware.Stack) error { 2742 return stack.Initialize.Add(&validateOpUpdateAssociation{}, middleware.After) 2743} 2744 2745func addOpUpdateAssociationStatusValidationMiddleware(stack *middleware.Stack) error { 2746 return stack.Initialize.Add(&validateOpUpdateAssociationStatus{}, middleware.After) 2747} 2748 2749func addOpUpdateDocumentDefaultVersionValidationMiddleware(stack *middleware.Stack) error { 2750 return stack.Initialize.Add(&validateOpUpdateDocumentDefaultVersion{}, middleware.After) 2751} 2752 2753func addOpUpdateDocumentValidationMiddleware(stack *middleware.Stack) error { 2754 return stack.Initialize.Add(&validateOpUpdateDocument{}, middleware.After) 2755} 2756 2757func addOpUpdateDocumentMetadataValidationMiddleware(stack *middleware.Stack) error { 2758 return stack.Initialize.Add(&validateOpUpdateDocumentMetadata{}, middleware.After) 2759} 2760 2761func addOpUpdateMaintenanceWindowValidationMiddleware(stack *middleware.Stack) error { 2762 return stack.Initialize.Add(&validateOpUpdateMaintenanceWindow{}, middleware.After) 2763} 2764 2765func addOpUpdateMaintenanceWindowTargetValidationMiddleware(stack *middleware.Stack) error { 2766 return stack.Initialize.Add(&validateOpUpdateMaintenanceWindowTarget{}, middleware.After) 2767} 2768 2769func addOpUpdateMaintenanceWindowTaskValidationMiddleware(stack *middleware.Stack) error { 2770 return stack.Initialize.Add(&validateOpUpdateMaintenanceWindowTask{}, middleware.After) 2771} 2772 2773func addOpUpdateManagedInstanceRoleValidationMiddleware(stack *middleware.Stack) error { 2774 return stack.Initialize.Add(&validateOpUpdateManagedInstanceRole{}, middleware.After) 2775} 2776 2777func addOpUpdateOpsItemValidationMiddleware(stack *middleware.Stack) error { 2778 return stack.Initialize.Add(&validateOpUpdateOpsItem{}, middleware.After) 2779} 2780 2781func addOpUpdateOpsMetadataValidationMiddleware(stack *middleware.Stack) error { 2782 return stack.Initialize.Add(&validateOpUpdateOpsMetadata{}, middleware.After) 2783} 2784 2785func addOpUpdatePatchBaselineValidationMiddleware(stack *middleware.Stack) error { 2786 return stack.Initialize.Add(&validateOpUpdatePatchBaseline{}, middleware.After) 2787} 2788 2789func addOpUpdateResourceDataSyncValidationMiddleware(stack *middleware.Stack) error { 2790 return stack.Initialize.Add(&validateOpUpdateResourceDataSync{}, middleware.After) 2791} 2792 2793func addOpUpdateServiceSettingValidationMiddleware(stack *middleware.Stack) error { 2794 return stack.Initialize.Add(&validateOpUpdateServiceSetting{}, middleware.After) 2795} 2796 2797func validateAssociationExecutionFilter(v *types.AssociationExecutionFilter) error { 2798 if v == nil { 2799 return nil 2800 } 2801 invalidParams := smithy.InvalidParamsError{Context: "AssociationExecutionFilter"} 2802 if len(v.Key) == 0 { 2803 invalidParams.Add(smithy.NewErrParamRequired("Key")) 2804 } 2805 if v.Value == nil { 2806 invalidParams.Add(smithy.NewErrParamRequired("Value")) 2807 } 2808 if len(v.Type) == 0 { 2809 invalidParams.Add(smithy.NewErrParamRequired("Type")) 2810 } 2811 if invalidParams.Len() > 0 { 2812 return invalidParams 2813 } else { 2814 return nil 2815 } 2816} 2817 2818func validateAssociationExecutionFilterList(v []types.AssociationExecutionFilter) error { 2819 if v == nil { 2820 return nil 2821 } 2822 invalidParams := smithy.InvalidParamsError{Context: "AssociationExecutionFilterList"} 2823 for i := range v { 2824 if err := validateAssociationExecutionFilter(&v[i]); err != nil { 2825 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2826 } 2827 } 2828 if invalidParams.Len() > 0 { 2829 return invalidParams 2830 } else { 2831 return nil 2832 } 2833} 2834 2835func validateAssociationExecutionTargetsFilter(v *types.AssociationExecutionTargetsFilter) error { 2836 if v == nil { 2837 return nil 2838 } 2839 invalidParams := smithy.InvalidParamsError{Context: "AssociationExecutionTargetsFilter"} 2840 if len(v.Key) == 0 { 2841 invalidParams.Add(smithy.NewErrParamRequired("Key")) 2842 } 2843 if v.Value == nil { 2844 invalidParams.Add(smithy.NewErrParamRequired("Value")) 2845 } 2846 if invalidParams.Len() > 0 { 2847 return invalidParams 2848 } else { 2849 return nil 2850 } 2851} 2852 2853func validateAssociationExecutionTargetsFilterList(v []types.AssociationExecutionTargetsFilter) error { 2854 if v == nil { 2855 return nil 2856 } 2857 invalidParams := smithy.InvalidParamsError{Context: "AssociationExecutionTargetsFilterList"} 2858 for i := range v { 2859 if err := validateAssociationExecutionTargetsFilter(&v[i]); err != nil { 2860 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2861 } 2862 } 2863 if invalidParams.Len() > 0 { 2864 return invalidParams 2865 } else { 2866 return nil 2867 } 2868} 2869 2870func validateAssociationFilter(v *types.AssociationFilter) error { 2871 if v == nil { 2872 return nil 2873 } 2874 invalidParams := smithy.InvalidParamsError{Context: "AssociationFilter"} 2875 if len(v.Key) == 0 { 2876 invalidParams.Add(smithy.NewErrParamRequired("Key")) 2877 } 2878 if v.Value == nil { 2879 invalidParams.Add(smithy.NewErrParamRequired("Value")) 2880 } 2881 if invalidParams.Len() > 0 { 2882 return invalidParams 2883 } else { 2884 return nil 2885 } 2886} 2887 2888func validateAssociationFilterList(v []types.AssociationFilter) error { 2889 if v == nil { 2890 return nil 2891 } 2892 invalidParams := smithy.InvalidParamsError{Context: "AssociationFilterList"} 2893 for i := range v { 2894 if err := validateAssociationFilter(&v[i]); err != nil { 2895 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2896 } 2897 } 2898 if invalidParams.Len() > 0 { 2899 return invalidParams 2900 } else { 2901 return nil 2902 } 2903} 2904 2905func validateAssociationStatus(v *types.AssociationStatus) error { 2906 if v == nil { 2907 return nil 2908 } 2909 invalidParams := smithy.InvalidParamsError{Context: "AssociationStatus"} 2910 if v.Date == nil { 2911 invalidParams.Add(smithy.NewErrParamRequired("Date")) 2912 } 2913 if len(v.Name) == 0 { 2914 invalidParams.Add(smithy.NewErrParamRequired("Name")) 2915 } 2916 if v.Message == nil { 2917 invalidParams.Add(smithy.NewErrParamRequired("Message")) 2918 } 2919 if invalidParams.Len() > 0 { 2920 return invalidParams 2921 } else { 2922 return nil 2923 } 2924} 2925 2926func validateAutomationExecutionFilter(v *types.AutomationExecutionFilter) error { 2927 if v == nil { 2928 return nil 2929 } 2930 invalidParams := smithy.InvalidParamsError{Context: "AutomationExecutionFilter"} 2931 if len(v.Key) == 0 { 2932 invalidParams.Add(smithy.NewErrParamRequired("Key")) 2933 } 2934 if v.Values == nil { 2935 invalidParams.Add(smithy.NewErrParamRequired("Values")) 2936 } 2937 if invalidParams.Len() > 0 { 2938 return invalidParams 2939 } else { 2940 return nil 2941 } 2942} 2943 2944func validateAutomationExecutionFilterList(v []types.AutomationExecutionFilter) error { 2945 if v == nil { 2946 return nil 2947 } 2948 invalidParams := smithy.InvalidParamsError{Context: "AutomationExecutionFilterList"} 2949 for i := range v { 2950 if err := validateAutomationExecutionFilter(&v[i]); err != nil { 2951 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2952 } 2953 } 2954 if invalidParams.Len() > 0 { 2955 return invalidParams 2956 } else { 2957 return nil 2958 } 2959} 2960 2961func validateCommandFilter(v *types.CommandFilter) error { 2962 if v == nil { 2963 return nil 2964 } 2965 invalidParams := smithy.InvalidParamsError{Context: "CommandFilter"} 2966 if len(v.Key) == 0 { 2967 invalidParams.Add(smithy.NewErrParamRequired("Key")) 2968 } 2969 if v.Value == nil { 2970 invalidParams.Add(smithy.NewErrParamRequired("Value")) 2971 } 2972 if invalidParams.Len() > 0 { 2973 return invalidParams 2974 } else { 2975 return nil 2976 } 2977} 2978 2979func validateCommandFilterList(v []types.CommandFilter) error { 2980 if v == nil { 2981 return nil 2982 } 2983 invalidParams := smithy.InvalidParamsError{Context: "CommandFilterList"} 2984 for i := range v { 2985 if err := validateCommandFilter(&v[i]); err != nil { 2986 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2987 } 2988 } 2989 if invalidParams.Len() > 0 { 2990 return invalidParams 2991 } else { 2992 return nil 2993 } 2994} 2995 2996func validateComplianceExecutionSummary(v *types.ComplianceExecutionSummary) error { 2997 if v == nil { 2998 return nil 2999 } 3000 invalidParams := smithy.InvalidParamsError{Context: "ComplianceExecutionSummary"} 3001 if v.ExecutionTime == nil { 3002 invalidParams.Add(smithy.NewErrParamRequired("ExecutionTime")) 3003 } 3004 if invalidParams.Len() > 0 { 3005 return invalidParams 3006 } else { 3007 return nil 3008 } 3009} 3010 3011func validateComplianceItemEntry(v *types.ComplianceItemEntry) error { 3012 if v == nil { 3013 return nil 3014 } 3015 invalidParams := smithy.InvalidParamsError{Context: "ComplianceItemEntry"} 3016 if len(v.Severity) == 0 { 3017 invalidParams.Add(smithy.NewErrParamRequired("Severity")) 3018 } 3019 if len(v.Status) == 0 { 3020 invalidParams.Add(smithy.NewErrParamRequired("Status")) 3021 } 3022 if invalidParams.Len() > 0 { 3023 return invalidParams 3024 } else { 3025 return nil 3026 } 3027} 3028 3029func validateComplianceItemEntryList(v []types.ComplianceItemEntry) error { 3030 if v == nil { 3031 return nil 3032 } 3033 invalidParams := smithy.InvalidParamsError{Context: "ComplianceItemEntryList"} 3034 for i := range v { 3035 if err := validateComplianceItemEntry(&v[i]); err != nil { 3036 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3037 } 3038 } 3039 if invalidParams.Len() > 0 { 3040 return invalidParams 3041 } else { 3042 return nil 3043 } 3044} 3045 3046func validateCreateAssociationBatchRequestEntries(v []types.CreateAssociationBatchRequestEntry) error { 3047 if v == nil { 3048 return nil 3049 } 3050 invalidParams := smithy.InvalidParamsError{Context: "CreateAssociationBatchRequestEntries"} 3051 for i := range v { 3052 if err := validateCreateAssociationBatchRequestEntry(&v[i]); err != nil { 3053 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3054 } 3055 } 3056 if invalidParams.Len() > 0 { 3057 return invalidParams 3058 } else { 3059 return nil 3060 } 3061} 3062 3063func validateCreateAssociationBatchRequestEntry(v *types.CreateAssociationBatchRequestEntry) error { 3064 if v == nil { 3065 return nil 3066 } 3067 invalidParams := smithy.InvalidParamsError{Context: "CreateAssociationBatchRequestEntry"} 3068 if v.Name == nil { 3069 invalidParams.Add(smithy.NewErrParamRequired("Name")) 3070 } 3071 if invalidParams.Len() > 0 { 3072 return invalidParams 3073 } else { 3074 return nil 3075 } 3076} 3077 3078func validateDocumentFilter(v *types.DocumentFilter) error { 3079 if v == nil { 3080 return nil 3081 } 3082 invalidParams := smithy.InvalidParamsError{Context: "DocumentFilter"} 3083 if len(v.Key) == 0 { 3084 invalidParams.Add(smithy.NewErrParamRequired("Key")) 3085 } 3086 if v.Value == nil { 3087 invalidParams.Add(smithy.NewErrParamRequired("Value")) 3088 } 3089 if invalidParams.Len() > 0 { 3090 return invalidParams 3091 } else { 3092 return nil 3093 } 3094} 3095 3096func validateDocumentFilterList(v []types.DocumentFilter) error { 3097 if v == nil { 3098 return nil 3099 } 3100 invalidParams := smithy.InvalidParamsError{Context: "DocumentFilterList"} 3101 for i := range v { 3102 if err := validateDocumentFilter(&v[i]); err != nil { 3103 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3104 } 3105 } 3106 if invalidParams.Len() > 0 { 3107 return invalidParams 3108 } else { 3109 return nil 3110 } 3111} 3112 3113func validateDocumentRequires(v *types.DocumentRequires) error { 3114 if v == nil { 3115 return nil 3116 } 3117 invalidParams := smithy.InvalidParamsError{Context: "DocumentRequires"} 3118 if v.Name == nil { 3119 invalidParams.Add(smithy.NewErrParamRequired("Name")) 3120 } 3121 if invalidParams.Len() > 0 { 3122 return invalidParams 3123 } else { 3124 return nil 3125 } 3126} 3127 3128func validateDocumentRequiresList(v []types.DocumentRequires) error { 3129 if v == nil { 3130 return nil 3131 } 3132 invalidParams := smithy.InvalidParamsError{Context: "DocumentRequiresList"} 3133 for i := range v { 3134 if err := validateDocumentRequires(&v[i]); err != nil { 3135 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3136 } 3137 } 3138 if invalidParams.Len() > 0 { 3139 return invalidParams 3140 } else { 3141 return nil 3142 } 3143} 3144 3145func validateDocumentReviews(v *types.DocumentReviews) error { 3146 if v == nil { 3147 return nil 3148 } 3149 invalidParams := smithy.InvalidParamsError{Context: "DocumentReviews"} 3150 if len(v.Action) == 0 { 3151 invalidParams.Add(smithy.NewErrParamRequired("Action")) 3152 } 3153 if invalidParams.Len() > 0 { 3154 return invalidParams 3155 } else { 3156 return nil 3157 } 3158} 3159 3160func validateInstanceInformationFilter(v *types.InstanceInformationFilter) error { 3161 if v == nil { 3162 return nil 3163 } 3164 invalidParams := smithy.InvalidParamsError{Context: "InstanceInformationFilter"} 3165 if len(v.Key) == 0 { 3166 invalidParams.Add(smithy.NewErrParamRequired("Key")) 3167 } 3168 if v.ValueSet == nil { 3169 invalidParams.Add(smithy.NewErrParamRequired("ValueSet")) 3170 } 3171 if invalidParams.Len() > 0 { 3172 return invalidParams 3173 } else { 3174 return nil 3175 } 3176} 3177 3178func validateInstanceInformationFilterList(v []types.InstanceInformationFilter) error { 3179 if v == nil { 3180 return nil 3181 } 3182 invalidParams := smithy.InvalidParamsError{Context: "InstanceInformationFilterList"} 3183 for i := range v { 3184 if err := validateInstanceInformationFilter(&v[i]); err != nil { 3185 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3186 } 3187 } 3188 if invalidParams.Len() > 0 { 3189 return invalidParams 3190 } else { 3191 return nil 3192 } 3193} 3194 3195func validateInstanceInformationStringFilter(v *types.InstanceInformationStringFilter) error { 3196 if v == nil { 3197 return nil 3198 } 3199 invalidParams := smithy.InvalidParamsError{Context: "InstanceInformationStringFilter"} 3200 if v.Key == nil { 3201 invalidParams.Add(smithy.NewErrParamRequired("Key")) 3202 } 3203 if v.Values == nil { 3204 invalidParams.Add(smithy.NewErrParamRequired("Values")) 3205 } 3206 if invalidParams.Len() > 0 { 3207 return invalidParams 3208 } else { 3209 return nil 3210 } 3211} 3212 3213func validateInstanceInformationStringFilterList(v []types.InstanceInformationStringFilter) error { 3214 if v == nil { 3215 return nil 3216 } 3217 invalidParams := smithy.InvalidParamsError{Context: "InstanceInformationStringFilterList"} 3218 for i := range v { 3219 if err := validateInstanceInformationStringFilter(&v[i]); err != nil { 3220 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3221 } 3222 } 3223 if invalidParams.Len() > 0 { 3224 return invalidParams 3225 } else { 3226 return nil 3227 } 3228} 3229 3230func validateInstancePatchStateFilter(v *types.InstancePatchStateFilter) error { 3231 if v == nil { 3232 return nil 3233 } 3234 invalidParams := smithy.InvalidParamsError{Context: "InstancePatchStateFilter"} 3235 if v.Key == nil { 3236 invalidParams.Add(smithy.NewErrParamRequired("Key")) 3237 } 3238 if v.Values == nil { 3239 invalidParams.Add(smithy.NewErrParamRequired("Values")) 3240 } 3241 if len(v.Type) == 0 { 3242 invalidParams.Add(smithy.NewErrParamRequired("Type")) 3243 } 3244 if invalidParams.Len() > 0 { 3245 return invalidParams 3246 } else { 3247 return nil 3248 } 3249} 3250 3251func validateInstancePatchStateFilterList(v []types.InstancePatchStateFilter) error { 3252 if v == nil { 3253 return nil 3254 } 3255 invalidParams := smithy.InvalidParamsError{Context: "InstancePatchStateFilterList"} 3256 for i := range v { 3257 if err := validateInstancePatchStateFilter(&v[i]); err != nil { 3258 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3259 } 3260 } 3261 if invalidParams.Len() > 0 { 3262 return invalidParams 3263 } else { 3264 return nil 3265 } 3266} 3267 3268func validateInventoryAggregator(v *types.InventoryAggregator) error { 3269 if v == nil { 3270 return nil 3271 } 3272 invalidParams := smithy.InvalidParamsError{Context: "InventoryAggregator"} 3273 if v.Aggregators != nil { 3274 if err := validateInventoryAggregatorList(v.Aggregators); err != nil { 3275 invalidParams.AddNested("Aggregators", err.(smithy.InvalidParamsError)) 3276 } 3277 } 3278 if v.Groups != nil { 3279 if err := validateInventoryGroupList(v.Groups); err != nil { 3280 invalidParams.AddNested("Groups", err.(smithy.InvalidParamsError)) 3281 } 3282 } 3283 if invalidParams.Len() > 0 { 3284 return invalidParams 3285 } else { 3286 return nil 3287 } 3288} 3289 3290func validateInventoryAggregatorList(v []types.InventoryAggregator) error { 3291 if v == nil { 3292 return nil 3293 } 3294 invalidParams := smithy.InvalidParamsError{Context: "InventoryAggregatorList"} 3295 for i := range v { 3296 if err := validateInventoryAggregator(&v[i]); err != nil { 3297 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3298 } 3299 } 3300 if invalidParams.Len() > 0 { 3301 return invalidParams 3302 } else { 3303 return nil 3304 } 3305} 3306 3307func validateInventoryFilter(v *types.InventoryFilter) error { 3308 if v == nil { 3309 return nil 3310 } 3311 invalidParams := smithy.InvalidParamsError{Context: "InventoryFilter"} 3312 if v.Key == nil { 3313 invalidParams.Add(smithy.NewErrParamRequired("Key")) 3314 } 3315 if v.Values == nil { 3316 invalidParams.Add(smithy.NewErrParamRequired("Values")) 3317 } 3318 if invalidParams.Len() > 0 { 3319 return invalidParams 3320 } else { 3321 return nil 3322 } 3323} 3324 3325func validateInventoryFilterList(v []types.InventoryFilter) error { 3326 if v == nil { 3327 return nil 3328 } 3329 invalidParams := smithy.InvalidParamsError{Context: "InventoryFilterList"} 3330 for i := range v { 3331 if err := validateInventoryFilter(&v[i]); err != nil { 3332 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3333 } 3334 } 3335 if invalidParams.Len() > 0 { 3336 return invalidParams 3337 } else { 3338 return nil 3339 } 3340} 3341 3342func validateInventoryGroup(v *types.InventoryGroup) error { 3343 if v == nil { 3344 return nil 3345 } 3346 invalidParams := smithy.InvalidParamsError{Context: "InventoryGroup"} 3347 if v.Name == nil { 3348 invalidParams.Add(smithy.NewErrParamRequired("Name")) 3349 } 3350 if v.Filters == nil { 3351 invalidParams.Add(smithy.NewErrParamRequired("Filters")) 3352 } else if v.Filters != nil { 3353 if err := validateInventoryFilterList(v.Filters); err != nil { 3354 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 3355 } 3356 } 3357 if invalidParams.Len() > 0 { 3358 return invalidParams 3359 } else { 3360 return nil 3361 } 3362} 3363 3364func validateInventoryGroupList(v []types.InventoryGroup) error { 3365 if v == nil { 3366 return nil 3367 } 3368 invalidParams := smithy.InvalidParamsError{Context: "InventoryGroupList"} 3369 for i := range v { 3370 if err := validateInventoryGroup(&v[i]); err != nil { 3371 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3372 } 3373 } 3374 if invalidParams.Len() > 0 { 3375 return invalidParams 3376 } else { 3377 return nil 3378 } 3379} 3380 3381func validateInventoryItem(v *types.InventoryItem) error { 3382 if v == nil { 3383 return nil 3384 } 3385 invalidParams := smithy.InvalidParamsError{Context: "InventoryItem"} 3386 if v.TypeName == nil { 3387 invalidParams.Add(smithy.NewErrParamRequired("TypeName")) 3388 } 3389 if v.SchemaVersion == nil { 3390 invalidParams.Add(smithy.NewErrParamRequired("SchemaVersion")) 3391 } 3392 if v.CaptureTime == nil { 3393 invalidParams.Add(smithy.NewErrParamRequired("CaptureTime")) 3394 } 3395 if invalidParams.Len() > 0 { 3396 return invalidParams 3397 } else { 3398 return nil 3399 } 3400} 3401 3402func validateInventoryItemList(v []types.InventoryItem) error { 3403 if v == nil { 3404 return nil 3405 } 3406 invalidParams := smithy.InvalidParamsError{Context: "InventoryItemList"} 3407 for i := range v { 3408 if err := validateInventoryItem(&v[i]); err != nil { 3409 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3410 } 3411 } 3412 if invalidParams.Len() > 0 { 3413 return invalidParams 3414 } else { 3415 return nil 3416 } 3417} 3418 3419func validateLoggingInfo(v *types.LoggingInfo) error { 3420 if v == nil { 3421 return nil 3422 } 3423 invalidParams := smithy.InvalidParamsError{Context: "LoggingInfo"} 3424 if v.S3BucketName == nil { 3425 invalidParams.Add(smithy.NewErrParamRequired("S3BucketName")) 3426 } 3427 if v.S3Region == nil { 3428 invalidParams.Add(smithy.NewErrParamRequired("S3Region")) 3429 } 3430 if invalidParams.Len() > 0 { 3431 return invalidParams 3432 } else { 3433 return nil 3434 } 3435} 3436 3437func validateOpsAggregator(v *types.OpsAggregator) error { 3438 if v == nil { 3439 return nil 3440 } 3441 invalidParams := smithy.InvalidParamsError{Context: "OpsAggregator"} 3442 if v.Filters != nil { 3443 if err := validateOpsFilterList(v.Filters); err != nil { 3444 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 3445 } 3446 } 3447 if v.Aggregators != nil { 3448 if err := validateOpsAggregatorList(v.Aggregators); err != nil { 3449 invalidParams.AddNested("Aggregators", err.(smithy.InvalidParamsError)) 3450 } 3451 } 3452 if invalidParams.Len() > 0 { 3453 return invalidParams 3454 } else { 3455 return nil 3456 } 3457} 3458 3459func validateOpsAggregatorList(v []types.OpsAggregator) error { 3460 if v == nil { 3461 return nil 3462 } 3463 invalidParams := smithy.InvalidParamsError{Context: "OpsAggregatorList"} 3464 for i := range v { 3465 if err := validateOpsAggregator(&v[i]); err != nil { 3466 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3467 } 3468 } 3469 if invalidParams.Len() > 0 { 3470 return invalidParams 3471 } else { 3472 return nil 3473 } 3474} 3475 3476func validateOpsFilter(v *types.OpsFilter) error { 3477 if v == nil { 3478 return nil 3479 } 3480 invalidParams := smithy.InvalidParamsError{Context: "OpsFilter"} 3481 if v.Key == nil { 3482 invalidParams.Add(smithy.NewErrParamRequired("Key")) 3483 } 3484 if v.Values == nil { 3485 invalidParams.Add(smithy.NewErrParamRequired("Values")) 3486 } 3487 if invalidParams.Len() > 0 { 3488 return invalidParams 3489 } else { 3490 return nil 3491 } 3492} 3493 3494func validateOpsFilterList(v []types.OpsFilter) error { 3495 if v == nil { 3496 return nil 3497 } 3498 invalidParams := smithy.InvalidParamsError{Context: "OpsFilterList"} 3499 for i := range v { 3500 if err := validateOpsFilter(&v[i]); err != nil { 3501 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3502 } 3503 } 3504 if invalidParams.Len() > 0 { 3505 return invalidParams 3506 } else { 3507 return nil 3508 } 3509} 3510 3511func validateOpsItemEventFilter(v *types.OpsItemEventFilter) error { 3512 if v == nil { 3513 return nil 3514 } 3515 invalidParams := smithy.InvalidParamsError{Context: "OpsItemEventFilter"} 3516 if len(v.Key) == 0 { 3517 invalidParams.Add(smithy.NewErrParamRequired("Key")) 3518 } 3519 if v.Values == nil { 3520 invalidParams.Add(smithy.NewErrParamRequired("Values")) 3521 } 3522 if len(v.Operator) == 0 { 3523 invalidParams.Add(smithy.NewErrParamRequired("Operator")) 3524 } 3525 if invalidParams.Len() > 0 { 3526 return invalidParams 3527 } else { 3528 return nil 3529 } 3530} 3531 3532func validateOpsItemEventFilters(v []types.OpsItemEventFilter) error { 3533 if v == nil { 3534 return nil 3535 } 3536 invalidParams := smithy.InvalidParamsError{Context: "OpsItemEventFilters"} 3537 for i := range v { 3538 if err := validateOpsItemEventFilter(&v[i]); err != nil { 3539 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3540 } 3541 } 3542 if invalidParams.Len() > 0 { 3543 return invalidParams 3544 } else { 3545 return nil 3546 } 3547} 3548 3549func validateOpsItemFilter(v *types.OpsItemFilter) error { 3550 if v == nil { 3551 return nil 3552 } 3553 invalidParams := smithy.InvalidParamsError{Context: "OpsItemFilter"} 3554 if len(v.Key) == 0 { 3555 invalidParams.Add(smithy.NewErrParamRequired("Key")) 3556 } 3557 if v.Values == nil { 3558 invalidParams.Add(smithy.NewErrParamRequired("Values")) 3559 } 3560 if len(v.Operator) == 0 { 3561 invalidParams.Add(smithy.NewErrParamRequired("Operator")) 3562 } 3563 if invalidParams.Len() > 0 { 3564 return invalidParams 3565 } else { 3566 return nil 3567 } 3568} 3569 3570func validateOpsItemFilters(v []types.OpsItemFilter) error { 3571 if v == nil { 3572 return nil 3573 } 3574 invalidParams := smithy.InvalidParamsError{Context: "OpsItemFilters"} 3575 for i := range v { 3576 if err := validateOpsItemFilter(&v[i]); err != nil { 3577 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3578 } 3579 } 3580 if invalidParams.Len() > 0 { 3581 return invalidParams 3582 } else { 3583 return nil 3584 } 3585} 3586 3587func validateOpsMetadataFilter(v *types.OpsMetadataFilter) error { 3588 if v == nil { 3589 return nil 3590 } 3591 invalidParams := smithy.InvalidParamsError{Context: "OpsMetadataFilter"} 3592 if v.Key == nil { 3593 invalidParams.Add(smithy.NewErrParamRequired("Key")) 3594 } 3595 if v.Values == nil { 3596 invalidParams.Add(smithy.NewErrParamRequired("Values")) 3597 } 3598 if invalidParams.Len() > 0 { 3599 return invalidParams 3600 } else { 3601 return nil 3602 } 3603} 3604 3605func validateOpsMetadataFilterList(v []types.OpsMetadataFilter) error { 3606 if v == nil { 3607 return nil 3608 } 3609 invalidParams := smithy.InvalidParamsError{Context: "OpsMetadataFilterList"} 3610 for i := range v { 3611 if err := validateOpsMetadataFilter(&v[i]); err != nil { 3612 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3613 } 3614 } 3615 if invalidParams.Len() > 0 { 3616 return invalidParams 3617 } else { 3618 return nil 3619 } 3620} 3621 3622func validateOpsResultAttribute(v *types.OpsResultAttribute) error { 3623 if v == nil { 3624 return nil 3625 } 3626 invalidParams := smithy.InvalidParamsError{Context: "OpsResultAttribute"} 3627 if v.TypeName == nil { 3628 invalidParams.Add(smithy.NewErrParamRequired("TypeName")) 3629 } 3630 if invalidParams.Len() > 0 { 3631 return invalidParams 3632 } else { 3633 return nil 3634 } 3635} 3636 3637func validateOpsResultAttributeList(v []types.OpsResultAttribute) error { 3638 if v == nil { 3639 return nil 3640 } 3641 invalidParams := smithy.InvalidParamsError{Context: "OpsResultAttributeList"} 3642 for i := range v { 3643 if err := validateOpsResultAttribute(&v[i]); err != nil { 3644 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3645 } 3646 } 3647 if invalidParams.Len() > 0 { 3648 return invalidParams 3649 } else { 3650 return nil 3651 } 3652} 3653 3654func validateParametersFilter(v *types.ParametersFilter) error { 3655 if v == nil { 3656 return nil 3657 } 3658 invalidParams := smithy.InvalidParamsError{Context: "ParametersFilter"} 3659 if len(v.Key) == 0 { 3660 invalidParams.Add(smithy.NewErrParamRequired("Key")) 3661 } 3662 if v.Values == nil { 3663 invalidParams.Add(smithy.NewErrParamRequired("Values")) 3664 } 3665 if invalidParams.Len() > 0 { 3666 return invalidParams 3667 } else { 3668 return nil 3669 } 3670} 3671 3672func validateParametersFilterList(v []types.ParametersFilter) error { 3673 if v == nil { 3674 return nil 3675 } 3676 invalidParams := smithy.InvalidParamsError{Context: "ParametersFilterList"} 3677 for i := range v { 3678 if err := validateParametersFilter(&v[i]); err != nil { 3679 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3680 } 3681 } 3682 if invalidParams.Len() > 0 { 3683 return invalidParams 3684 } else { 3685 return nil 3686 } 3687} 3688 3689func validateParameterStringFilter(v *types.ParameterStringFilter) error { 3690 if v == nil { 3691 return nil 3692 } 3693 invalidParams := smithy.InvalidParamsError{Context: "ParameterStringFilter"} 3694 if v.Key == nil { 3695 invalidParams.Add(smithy.NewErrParamRequired("Key")) 3696 } 3697 if invalidParams.Len() > 0 { 3698 return invalidParams 3699 } else { 3700 return nil 3701 } 3702} 3703 3704func validateParameterStringFilterList(v []types.ParameterStringFilter) error { 3705 if v == nil { 3706 return nil 3707 } 3708 invalidParams := smithy.InvalidParamsError{Context: "ParameterStringFilterList"} 3709 for i := range v { 3710 if err := validateParameterStringFilter(&v[i]); err != nil { 3711 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3712 } 3713 } 3714 if invalidParams.Len() > 0 { 3715 return invalidParams 3716 } else { 3717 return nil 3718 } 3719} 3720 3721func validatePatchFilter(v *types.PatchFilter) error { 3722 if v == nil { 3723 return nil 3724 } 3725 invalidParams := smithy.InvalidParamsError{Context: "PatchFilter"} 3726 if len(v.Key) == 0 { 3727 invalidParams.Add(smithy.NewErrParamRequired("Key")) 3728 } 3729 if v.Values == nil { 3730 invalidParams.Add(smithy.NewErrParamRequired("Values")) 3731 } 3732 if invalidParams.Len() > 0 { 3733 return invalidParams 3734 } else { 3735 return nil 3736 } 3737} 3738 3739func validatePatchFilterGroup(v *types.PatchFilterGroup) error { 3740 if v == nil { 3741 return nil 3742 } 3743 invalidParams := smithy.InvalidParamsError{Context: "PatchFilterGroup"} 3744 if v.PatchFilters == nil { 3745 invalidParams.Add(smithy.NewErrParamRequired("PatchFilters")) 3746 } else if v.PatchFilters != nil { 3747 if err := validatePatchFilterList(v.PatchFilters); err != nil { 3748 invalidParams.AddNested("PatchFilters", err.(smithy.InvalidParamsError)) 3749 } 3750 } 3751 if invalidParams.Len() > 0 { 3752 return invalidParams 3753 } else { 3754 return nil 3755 } 3756} 3757 3758func validatePatchFilterList(v []types.PatchFilter) error { 3759 if v == nil { 3760 return nil 3761 } 3762 invalidParams := smithy.InvalidParamsError{Context: "PatchFilterList"} 3763 for i := range v { 3764 if err := validatePatchFilter(&v[i]); err != nil { 3765 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3766 } 3767 } 3768 if invalidParams.Len() > 0 { 3769 return invalidParams 3770 } else { 3771 return nil 3772 } 3773} 3774 3775func validatePatchRule(v *types.PatchRule) error { 3776 if v == nil { 3777 return nil 3778 } 3779 invalidParams := smithy.InvalidParamsError{Context: "PatchRule"} 3780 if v.PatchFilterGroup == nil { 3781 invalidParams.Add(smithy.NewErrParamRequired("PatchFilterGroup")) 3782 } else if v.PatchFilterGroup != nil { 3783 if err := validatePatchFilterGroup(v.PatchFilterGroup); err != nil { 3784 invalidParams.AddNested("PatchFilterGroup", err.(smithy.InvalidParamsError)) 3785 } 3786 } 3787 if invalidParams.Len() > 0 { 3788 return invalidParams 3789 } else { 3790 return nil 3791 } 3792} 3793 3794func validatePatchRuleGroup(v *types.PatchRuleGroup) error { 3795 if v == nil { 3796 return nil 3797 } 3798 invalidParams := smithy.InvalidParamsError{Context: "PatchRuleGroup"} 3799 if v.PatchRules == nil { 3800 invalidParams.Add(smithy.NewErrParamRequired("PatchRules")) 3801 } else if v.PatchRules != nil { 3802 if err := validatePatchRuleList(v.PatchRules); err != nil { 3803 invalidParams.AddNested("PatchRules", err.(smithy.InvalidParamsError)) 3804 } 3805 } 3806 if invalidParams.Len() > 0 { 3807 return invalidParams 3808 } else { 3809 return nil 3810 } 3811} 3812 3813func validatePatchRuleList(v []types.PatchRule) error { 3814 if v == nil { 3815 return nil 3816 } 3817 invalidParams := smithy.InvalidParamsError{Context: "PatchRuleList"} 3818 for i := range v { 3819 if err := validatePatchRule(&v[i]); err != nil { 3820 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3821 } 3822 } 3823 if invalidParams.Len() > 0 { 3824 return invalidParams 3825 } else { 3826 return nil 3827 } 3828} 3829 3830func validatePatchSource(v *types.PatchSource) error { 3831 if v == nil { 3832 return nil 3833 } 3834 invalidParams := smithy.InvalidParamsError{Context: "PatchSource"} 3835 if v.Name == nil { 3836 invalidParams.Add(smithy.NewErrParamRequired("Name")) 3837 } 3838 if v.Products == nil { 3839 invalidParams.Add(smithy.NewErrParamRequired("Products")) 3840 } 3841 if v.Configuration == nil { 3842 invalidParams.Add(smithy.NewErrParamRequired("Configuration")) 3843 } 3844 if invalidParams.Len() > 0 { 3845 return invalidParams 3846 } else { 3847 return nil 3848 } 3849} 3850 3851func validatePatchSourceList(v []types.PatchSource) error { 3852 if v == nil { 3853 return nil 3854 } 3855 invalidParams := smithy.InvalidParamsError{Context: "PatchSourceList"} 3856 for i := range v { 3857 if err := validatePatchSource(&v[i]); err != nil { 3858 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3859 } 3860 } 3861 if invalidParams.Len() > 0 { 3862 return invalidParams 3863 } else { 3864 return nil 3865 } 3866} 3867 3868func validateRelatedOpsItem(v *types.RelatedOpsItem) error { 3869 if v == nil { 3870 return nil 3871 } 3872 invalidParams := smithy.InvalidParamsError{Context: "RelatedOpsItem"} 3873 if v.OpsItemId == nil { 3874 invalidParams.Add(smithy.NewErrParamRequired("OpsItemId")) 3875 } 3876 if invalidParams.Len() > 0 { 3877 return invalidParams 3878 } else { 3879 return nil 3880 } 3881} 3882 3883func validateRelatedOpsItems(v []types.RelatedOpsItem) error { 3884 if v == nil { 3885 return nil 3886 } 3887 invalidParams := smithy.InvalidParamsError{Context: "RelatedOpsItems"} 3888 for i := range v { 3889 if err := validateRelatedOpsItem(&v[i]); err != nil { 3890 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3891 } 3892 } 3893 if invalidParams.Len() > 0 { 3894 return invalidParams 3895 } else { 3896 return nil 3897 } 3898} 3899 3900func validateResourceDataSyncAwsOrganizationsSource(v *types.ResourceDataSyncAwsOrganizationsSource) error { 3901 if v == nil { 3902 return nil 3903 } 3904 invalidParams := smithy.InvalidParamsError{Context: "ResourceDataSyncAwsOrganizationsSource"} 3905 if v.OrganizationSourceType == nil { 3906 invalidParams.Add(smithy.NewErrParamRequired("OrganizationSourceType")) 3907 } 3908 if invalidParams.Len() > 0 { 3909 return invalidParams 3910 } else { 3911 return nil 3912 } 3913} 3914 3915func validateResourceDataSyncS3Destination(v *types.ResourceDataSyncS3Destination) error { 3916 if v == nil { 3917 return nil 3918 } 3919 invalidParams := smithy.InvalidParamsError{Context: "ResourceDataSyncS3Destination"} 3920 if v.BucketName == nil { 3921 invalidParams.Add(smithy.NewErrParamRequired("BucketName")) 3922 } 3923 if len(v.SyncFormat) == 0 { 3924 invalidParams.Add(smithy.NewErrParamRequired("SyncFormat")) 3925 } 3926 if v.Region == nil { 3927 invalidParams.Add(smithy.NewErrParamRequired("Region")) 3928 } 3929 if invalidParams.Len() > 0 { 3930 return invalidParams 3931 } else { 3932 return nil 3933 } 3934} 3935 3936func validateResourceDataSyncSource(v *types.ResourceDataSyncSource) error { 3937 if v == nil { 3938 return nil 3939 } 3940 invalidParams := smithy.InvalidParamsError{Context: "ResourceDataSyncSource"} 3941 if v.SourceType == nil { 3942 invalidParams.Add(smithy.NewErrParamRequired("SourceType")) 3943 } 3944 if v.AwsOrganizationsSource != nil { 3945 if err := validateResourceDataSyncAwsOrganizationsSource(v.AwsOrganizationsSource); err != nil { 3946 invalidParams.AddNested("AwsOrganizationsSource", err.(smithy.InvalidParamsError)) 3947 } 3948 } 3949 if v.SourceRegions == nil { 3950 invalidParams.Add(smithy.NewErrParamRequired("SourceRegions")) 3951 } 3952 if invalidParams.Len() > 0 { 3953 return invalidParams 3954 } else { 3955 return nil 3956 } 3957} 3958 3959func validateResultAttribute(v *types.ResultAttribute) error { 3960 if v == nil { 3961 return nil 3962 } 3963 invalidParams := smithy.InvalidParamsError{Context: "ResultAttribute"} 3964 if v.TypeName == nil { 3965 invalidParams.Add(smithy.NewErrParamRequired("TypeName")) 3966 } 3967 if invalidParams.Len() > 0 { 3968 return invalidParams 3969 } else { 3970 return nil 3971 } 3972} 3973 3974func validateResultAttributeList(v []types.ResultAttribute) error { 3975 if v == nil { 3976 return nil 3977 } 3978 invalidParams := smithy.InvalidParamsError{Context: "ResultAttributeList"} 3979 for i := range v { 3980 if err := validateResultAttribute(&v[i]); err != nil { 3981 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 3982 } 3983 } 3984 if invalidParams.Len() > 0 { 3985 return invalidParams 3986 } else { 3987 return nil 3988 } 3989} 3990 3991func validateRunbook(v *types.Runbook) error { 3992 if v == nil { 3993 return nil 3994 } 3995 invalidParams := smithy.InvalidParamsError{Context: "Runbook"} 3996 if v.DocumentName == nil { 3997 invalidParams.Add(smithy.NewErrParamRequired("DocumentName")) 3998 } 3999 if invalidParams.Len() > 0 { 4000 return invalidParams 4001 } else { 4002 return nil 4003 } 4004} 4005 4006func validateRunbooks(v []types.Runbook) error { 4007 if v == nil { 4008 return nil 4009 } 4010 invalidParams := smithy.InvalidParamsError{Context: "Runbooks"} 4011 for i := range v { 4012 if err := validateRunbook(&v[i]); err != nil { 4013 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 4014 } 4015 } 4016 if invalidParams.Len() > 0 { 4017 return invalidParams 4018 } else { 4019 return nil 4020 } 4021} 4022 4023func validateSessionFilter(v *types.SessionFilter) error { 4024 if v == nil { 4025 return nil 4026 } 4027 invalidParams := smithy.InvalidParamsError{Context: "SessionFilter"} 4028 if len(v.Key) == 0 { 4029 invalidParams.Add(smithy.NewErrParamRequired("Key")) 4030 } 4031 if v.Value == nil { 4032 invalidParams.Add(smithy.NewErrParamRequired("Value")) 4033 } 4034 if invalidParams.Len() > 0 { 4035 return invalidParams 4036 } else { 4037 return nil 4038 } 4039} 4040 4041func validateSessionFilterList(v []types.SessionFilter) error { 4042 if v == nil { 4043 return nil 4044 } 4045 invalidParams := smithy.InvalidParamsError{Context: "SessionFilterList"} 4046 for i := range v { 4047 if err := validateSessionFilter(&v[i]); err != nil { 4048 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 4049 } 4050 } 4051 if invalidParams.Len() > 0 { 4052 return invalidParams 4053 } else { 4054 return nil 4055 } 4056} 4057 4058func validateStepExecutionFilter(v *types.StepExecutionFilter) error { 4059 if v == nil { 4060 return nil 4061 } 4062 invalidParams := smithy.InvalidParamsError{Context: "StepExecutionFilter"} 4063 if len(v.Key) == 0 { 4064 invalidParams.Add(smithy.NewErrParamRequired("Key")) 4065 } 4066 if v.Values == nil { 4067 invalidParams.Add(smithy.NewErrParamRequired("Values")) 4068 } 4069 if invalidParams.Len() > 0 { 4070 return invalidParams 4071 } else { 4072 return nil 4073 } 4074} 4075 4076func validateStepExecutionFilterList(v []types.StepExecutionFilter) error { 4077 if v == nil { 4078 return nil 4079 } 4080 invalidParams := smithy.InvalidParamsError{Context: "StepExecutionFilterList"} 4081 for i := range v { 4082 if err := validateStepExecutionFilter(&v[i]); err != nil { 4083 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 4084 } 4085 } 4086 if invalidParams.Len() > 0 { 4087 return invalidParams 4088 } else { 4089 return nil 4090 } 4091} 4092 4093func validateTag(v *types.Tag) error { 4094 if v == nil { 4095 return nil 4096 } 4097 invalidParams := smithy.InvalidParamsError{Context: "Tag"} 4098 if v.Key == nil { 4099 invalidParams.Add(smithy.NewErrParamRequired("Key")) 4100 } 4101 if v.Value == nil { 4102 invalidParams.Add(smithy.NewErrParamRequired("Value")) 4103 } 4104 if invalidParams.Len() > 0 { 4105 return invalidParams 4106 } else { 4107 return nil 4108 } 4109} 4110 4111func validateTagList(v []types.Tag) error { 4112 if v == nil { 4113 return nil 4114 } 4115 invalidParams := smithy.InvalidParamsError{Context: "TagList"} 4116 for i := range v { 4117 if err := validateTag(&v[i]); err != nil { 4118 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 4119 } 4120 } 4121 if invalidParams.Len() > 0 { 4122 return invalidParams 4123 } else { 4124 return nil 4125 } 4126} 4127 4128func validateOpAddTagsToResourceInput(v *AddTagsToResourceInput) error { 4129 if v == nil { 4130 return nil 4131 } 4132 invalidParams := smithy.InvalidParamsError{Context: "AddTagsToResourceInput"} 4133 if len(v.ResourceType) == 0 { 4134 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 4135 } 4136 if v.ResourceId == nil { 4137 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 4138 } 4139 if v.Tags == nil { 4140 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 4141 } else if v.Tags != nil { 4142 if err := validateTagList(v.Tags); err != nil { 4143 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 4144 } 4145 } 4146 if invalidParams.Len() > 0 { 4147 return invalidParams 4148 } else { 4149 return nil 4150 } 4151} 4152 4153func validateOpCancelCommandInput(v *CancelCommandInput) error { 4154 if v == nil { 4155 return nil 4156 } 4157 invalidParams := smithy.InvalidParamsError{Context: "CancelCommandInput"} 4158 if v.CommandId == nil { 4159 invalidParams.Add(smithy.NewErrParamRequired("CommandId")) 4160 } 4161 if invalidParams.Len() > 0 { 4162 return invalidParams 4163 } else { 4164 return nil 4165 } 4166} 4167 4168func validateOpCancelMaintenanceWindowExecutionInput(v *CancelMaintenanceWindowExecutionInput) error { 4169 if v == nil { 4170 return nil 4171 } 4172 invalidParams := smithy.InvalidParamsError{Context: "CancelMaintenanceWindowExecutionInput"} 4173 if v.WindowExecutionId == nil { 4174 invalidParams.Add(smithy.NewErrParamRequired("WindowExecutionId")) 4175 } 4176 if invalidParams.Len() > 0 { 4177 return invalidParams 4178 } else { 4179 return nil 4180 } 4181} 4182 4183func validateOpCreateActivationInput(v *CreateActivationInput) error { 4184 if v == nil { 4185 return nil 4186 } 4187 invalidParams := smithy.InvalidParamsError{Context: "CreateActivationInput"} 4188 if v.IamRole == nil { 4189 invalidParams.Add(smithy.NewErrParamRequired("IamRole")) 4190 } 4191 if v.Tags != nil { 4192 if err := validateTagList(v.Tags); err != nil { 4193 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 4194 } 4195 } 4196 if invalidParams.Len() > 0 { 4197 return invalidParams 4198 } else { 4199 return nil 4200 } 4201} 4202 4203func validateOpCreateAssociationBatchInput(v *CreateAssociationBatchInput) error { 4204 if v == nil { 4205 return nil 4206 } 4207 invalidParams := smithy.InvalidParamsError{Context: "CreateAssociationBatchInput"} 4208 if v.Entries == nil { 4209 invalidParams.Add(smithy.NewErrParamRequired("Entries")) 4210 } else if v.Entries != nil { 4211 if err := validateCreateAssociationBatchRequestEntries(v.Entries); err != nil { 4212 invalidParams.AddNested("Entries", err.(smithy.InvalidParamsError)) 4213 } 4214 } 4215 if invalidParams.Len() > 0 { 4216 return invalidParams 4217 } else { 4218 return nil 4219 } 4220} 4221 4222func validateOpCreateAssociationInput(v *CreateAssociationInput) error { 4223 if v == nil { 4224 return nil 4225 } 4226 invalidParams := smithy.InvalidParamsError{Context: "CreateAssociationInput"} 4227 if v.Name == nil { 4228 invalidParams.Add(smithy.NewErrParamRequired("Name")) 4229 } 4230 if invalidParams.Len() > 0 { 4231 return invalidParams 4232 } else { 4233 return nil 4234 } 4235} 4236 4237func validateOpCreateDocumentInput(v *CreateDocumentInput) error { 4238 if v == nil { 4239 return nil 4240 } 4241 invalidParams := smithy.InvalidParamsError{Context: "CreateDocumentInput"} 4242 if v.Content == nil { 4243 invalidParams.Add(smithy.NewErrParamRequired("Content")) 4244 } 4245 if v.Requires != nil { 4246 if err := validateDocumentRequiresList(v.Requires); err != nil { 4247 invalidParams.AddNested("Requires", err.(smithy.InvalidParamsError)) 4248 } 4249 } 4250 if v.Name == nil { 4251 invalidParams.Add(smithy.NewErrParamRequired("Name")) 4252 } 4253 if v.Tags != nil { 4254 if err := validateTagList(v.Tags); err != nil { 4255 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 4256 } 4257 } 4258 if invalidParams.Len() > 0 { 4259 return invalidParams 4260 } else { 4261 return nil 4262 } 4263} 4264 4265func validateOpCreateMaintenanceWindowInput(v *CreateMaintenanceWindowInput) error { 4266 if v == nil { 4267 return nil 4268 } 4269 invalidParams := smithy.InvalidParamsError{Context: "CreateMaintenanceWindowInput"} 4270 if v.Name == nil { 4271 invalidParams.Add(smithy.NewErrParamRequired("Name")) 4272 } 4273 if v.Schedule == nil { 4274 invalidParams.Add(smithy.NewErrParamRequired("Schedule")) 4275 } 4276 if v.Tags != nil { 4277 if err := validateTagList(v.Tags); err != nil { 4278 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 4279 } 4280 } 4281 if invalidParams.Len() > 0 { 4282 return invalidParams 4283 } else { 4284 return nil 4285 } 4286} 4287 4288func validateOpCreateOpsItemInput(v *CreateOpsItemInput) error { 4289 if v == nil { 4290 return nil 4291 } 4292 invalidParams := smithy.InvalidParamsError{Context: "CreateOpsItemInput"} 4293 if v.Description == nil { 4294 invalidParams.Add(smithy.NewErrParamRequired("Description")) 4295 } 4296 if v.RelatedOpsItems != nil { 4297 if err := validateRelatedOpsItems(v.RelatedOpsItems); err != nil { 4298 invalidParams.AddNested("RelatedOpsItems", err.(smithy.InvalidParamsError)) 4299 } 4300 } 4301 if v.Source == nil { 4302 invalidParams.Add(smithy.NewErrParamRequired("Source")) 4303 } 4304 if v.Title == nil { 4305 invalidParams.Add(smithy.NewErrParamRequired("Title")) 4306 } 4307 if v.Tags != nil { 4308 if err := validateTagList(v.Tags); err != nil { 4309 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 4310 } 4311 } 4312 if invalidParams.Len() > 0 { 4313 return invalidParams 4314 } else { 4315 return nil 4316 } 4317} 4318 4319func validateOpCreateOpsMetadataInput(v *CreateOpsMetadataInput) error { 4320 if v == nil { 4321 return nil 4322 } 4323 invalidParams := smithy.InvalidParamsError{Context: "CreateOpsMetadataInput"} 4324 if v.ResourceId == nil { 4325 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 4326 } 4327 if invalidParams.Len() > 0 { 4328 return invalidParams 4329 } else { 4330 return nil 4331 } 4332} 4333 4334func validateOpCreatePatchBaselineInput(v *CreatePatchBaselineInput) error { 4335 if v == nil { 4336 return nil 4337 } 4338 invalidParams := smithy.InvalidParamsError{Context: "CreatePatchBaselineInput"} 4339 if v.Name == nil { 4340 invalidParams.Add(smithy.NewErrParamRequired("Name")) 4341 } 4342 if v.GlobalFilters != nil { 4343 if err := validatePatchFilterGroup(v.GlobalFilters); err != nil { 4344 invalidParams.AddNested("GlobalFilters", err.(smithy.InvalidParamsError)) 4345 } 4346 } 4347 if v.ApprovalRules != nil { 4348 if err := validatePatchRuleGroup(v.ApprovalRules); err != nil { 4349 invalidParams.AddNested("ApprovalRules", err.(smithy.InvalidParamsError)) 4350 } 4351 } 4352 if v.Sources != nil { 4353 if err := validatePatchSourceList(v.Sources); err != nil { 4354 invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError)) 4355 } 4356 } 4357 if v.Tags != nil { 4358 if err := validateTagList(v.Tags); err != nil { 4359 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 4360 } 4361 } 4362 if invalidParams.Len() > 0 { 4363 return invalidParams 4364 } else { 4365 return nil 4366 } 4367} 4368 4369func validateOpCreateResourceDataSyncInput(v *CreateResourceDataSyncInput) error { 4370 if v == nil { 4371 return nil 4372 } 4373 invalidParams := smithy.InvalidParamsError{Context: "CreateResourceDataSyncInput"} 4374 if v.SyncName == nil { 4375 invalidParams.Add(smithy.NewErrParamRequired("SyncName")) 4376 } 4377 if v.S3Destination != nil { 4378 if err := validateResourceDataSyncS3Destination(v.S3Destination); err != nil { 4379 invalidParams.AddNested("S3Destination", err.(smithy.InvalidParamsError)) 4380 } 4381 } 4382 if v.SyncSource != nil { 4383 if err := validateResourceDataSyncSource(v.SyncSource); err != nil { 4384 invalidParams.AddNested("SyncSource", err.(smithy.InvalidParamsError)) 4385 } 4386 } 4387 if invalidParams.Len() > 0 { 4388 return invalidParams 4389 } else { 4390 return nil 4391 } 4392} 4393 4394func validateOpDeleteActivationInput(v *DeleteActivationInput) error { 4395 if v == nil { 4396 return nil 4397 } 4398 invalidParams := smithy.InvalidParamsError{Context: "DeleteActivationInput"} 4399 if v.ActivationId == nil { 4400 invalidParams.Add(smithy.NewErrParamRequired("ActivationId")) 4401 } 4402 if invalidParams.Len() > 0 { 4403 return invalidParams 4404 } else { 4405 return nil 4406 } 4407} 4408 4409func validateOpDeleteDocumentInput(v *DeleteDocumentInput) error { 4410 if v == nil { 4411 return nil 4412 } 4413 invalidParams := smithy.InvalidParamsError{Context: "DeleteDocumentInput"} 4414 if v.Name == nil { 4415 invalidParams.Add(smithy.NewErrParamRequired("Name")) 4416 } 4417 if invalidParams.Len() > 0 { 4418 return invalidParams 4419 } else { 4420 return nil 4421 } 4422} 4423 4424func validateOpDeleteInventoryInput(v *DeleteInventoryInput) error { 4425 if v == nil { 4426 return nil 4427 } 4428 invalidParams := smithy.InvalidParamsError{Context: "DeleteInventoryInput"} 4429 if v.TypeName == nil { 4430 invalidParams.Add(smithy.NewErrParamRequired("TypeName")) 4431 } 4432 if invalidParams.Len() > 0 { 4433 return invalidParams 4434 } else { 4435 return nil 4436 } 4437} 4438 4439func validateOpDeleteMaintenanceWindowInput(v *DeleteMaintenanceWindowInput) error { 4440 if v == nil { 4441 return nil 4442 } 4443 invalidParams := smithy.InvalidParamsError{Context: "DeleteMaintenanceWindowInput"} 4444 if v.WindowId == nil { 4445 invalidParams.Add(smithy.NewErrParamRequired("WindowId")) 4446 } 4447 if invalidParams.Len() > 0 { 4448 return invalidParams 4449 } else { 4450 return nil 4451 } 4452} 4453 4454func validateOpDeleteOpsMetadataInput(v *DeleteOpsMetadataInput) error { 4455 if v == nil { 4456 return nil 4457 } 4458 invalidParams := smithy.InvalidParamsError{Context: "DeleteOpsMetadataInput"} 4459 if v.OpsMetadataArn == nil { 4460 invalidParams.Add(smithy.NewErrParamRequired("OpsMetadataArn")) 4461 } 4462 if invalidParams.Len() > 0 { 4463 return invalidParams 4464 } else { 4465 return nil 4466 } 4467} 4468 4469func validateOpDeleteParameterInput(v *DeleteParameterInput) error { 4470 if v == nil { 4471 return nil 4472 } 4473 invalidParams := smithy.InvalidParamsError{Context: "DeleteParameterInput"} 4474 if v.Name == nil { 4475 invalidParams.Add(smithy.NewErrParamRequired("Name")) 4476 } 4477 if invalidParams.Len() > 0 { 4478 return invalidParams 4479 } else { 4480 return nil 4481 } 4482} 4483 4484func validateOpDeleteParametersInput(v *DeleteParametersInput) error { 4485 if v == nil { 4486 return nil 4487 } 4488 invalidParams := smithy.InvalidParamsError{Context: "DeleteParametersInput"} 4489 if v.Names == nil { 4490 invalidParams.Add(smithy.NewErrParamRequired("Names")) 4491 } 4492 if invalidParams.Len() > 0 { 4493 return invalidParams 4494 } else { 4495 return nil 4496 } 4497} 4498 4499func validateOpDeletePatchBaselineInput(v *DeletePatchBaselineInput) error { 4500 if v == nil { 4501 return nil 4502 } 4503 invalidParams := smithy.InvalidParamsError{Context: "DeletePatchBaselineInput"} 4504 if v.BaselineId == nil { 4505 invalidParams.Add(smithy.NewErrParamRequired("BaselineId")) 4506 } 4507 if invalidParams.Len() > 0 { 4508 return invalidParams 4509 } else { 4510 return nil 4511 } 4512} 4513 4514func validateOpDeleteResourceDataSyncInput(v *DeleteResourceDataSyncInput) error { 4515 if v == nil { 4516 return nil 4517 } 4518 invalidParams := smithy.InvalidParamsError{Context: "DeleteResourceDataSyncInput"} 4519 if v.SyncName == nil { 4520 invalidParams.Add(smithy.NewErrParamRequired("SyncName")) 4521 } 4522 if invalidParams.Len() > 0 { 4523 return invalidParams 4524 } else { 4525 return nil 4526 } 4527} 4528 4529func validateOpDeregisterManagedInstanceInput(v *DeregisterManagedInstanceInput) error { 4530 if v == nil { 4531 return nil 4532 } 4533 invalidParams := smithy.InvalidParamsError{Context: "DeregisterManagedInstanceInput"} 4534 if v.InstanceId == nil { 4535 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 4536 } 4537 if invalidParams.Len() > 0 { 4538 return invalidParams 4539 } else { 4540 return nil 4541 } 4542} 4543 4544func validateOpDeregisterPatchBaselineForPatchGroupInput(v *DeregisterPatchBaselineForPatchGroupInput) error { 4545 if v == nil { 4546 return nil 4547 } 4548 invalidParams := smithy.InvalidParamsError{Context: "DeregisterPatchBaselineForPatchGroupInput"} 4549 if v.BaselineId == nil { 4550 invalidParams.Add(smithy.NewErrParamRequired("BaselineId")) 4551 } 4552 if v.PatchGroup == nil { 4553 invalidParams.Add(smithy.NewErrParamRequired("PatchGroup")) 4554 } 4555 if invalidParams.Len() > 0 { 4556 return invalidParams 4557 } else { 4558 return nil 4559 } 4560} 4561 4562func validateOpDeregisterTargetFromMaintenanceWindowInput(v *DeregisterTargetFromMaintenanceWindowInput) error { 4563 if v == nil { 4564 return nil 4565 } 4566 invalidParams := smithy.InvalidParamsError{Context: "DeregisterTargetFromMaintenanceWindowInput"} 4567 if v.WindowId == nil { 4568 invalidParams.Add(smithy.NewErrParamRequired("WindowId")) 4569 } 4570 if v.WindowTargetId == nil { 4571 invalidParams.Add(smithy.NewErrParamRequired("WindowTargetId")) 4572 } 4573 if invalidParams.Len() > 0 { 4574 return invalidParams 4575 } else { 4576 return nil 4577 } 4578} 4579 4580func validateOpDeregisterTaskFromMaintenanceWindowInput(v *DeregisterTaskFromMaintenanceWindowInput) error { 4581 if v == nil { 4582 return nil 4583 } 4584 invalidParams := smithy.InvalidParamsError{Context: "DeregisterTaskFromMaintenanceWindowInput"} 4585 if v.WindowId == nil { 4586 invalidParams.Add(smithy.NewErrParamRequired("WindowId")) 4587 } 4588 if v.WindowTaskId == nil { 4589 invalidParams.Add(smithy.NewErrParamRequired("WindowTaskId")) 4590 } 4591 if invalidParams.Len() > 0 { 4592 return invalidParams 4593 } else { 4594 return nil 4595 } 4596} 4597 4598func validateOpDescribeAssociationExecutionsInput(v *DescribeAssociationExecutionsInput) error { 4599 if v == nil { 4600 return nil 4601 } 4602 invalidParams := smithy.InvalidParamsError{Context: "DescribeAssociationExecutionsInput"} 4603 if v.AssociationId == nil { 4604 invalidParams.Add(smithy.NewErrParamRequired("AssociationId")) 4605 } 4606 if v.Filters != nil { 4607 if err := validateAssociationExecutionFilterList(v.Filters); err != nil { 4608 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 4609 } 4610 } 4611 if invalidParams.Len() > 0 { 4612 return invalidParams 4613 } else { 4614 return nil 4615 } 4616} 4617 4618func validateOpDescribeAssociationExecutionTargetsInput(v *DescribeAssociationExecutionTargetsInput) error { 4619 if v == nil { 4620 return nil 4621 } 4622 invalidParams := smithy.InvalidParamsError{Context: "DescribeAssociationExecutionTargetsInput"} 4623 if v.AssociationId == nil { 4624 invalidParams.Add(smithy.NewErrParamRequired("AssociationId")) 4625 } 4626 if v.ExecutionId == nil { 4627 invalidParams.Add(smithy.NewErrParamRequired("ExecutionId")) 4628 } 4629 if v.Filters != nil { 4630 if err := validateAssociationExecutionTargetsFilterList(v.Filters); err != nil { 4631 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 4632 } 4633 } 4634 if invalidParams.Len() > 0 { 4635 return invalidParams 4636 } else { 4637 return nil 4638 } 4639} 4640 4641func validateOpDescribeAutomationExecutionsInput(v *DescribeAutomationExecutionsInput) error { 4642 if v == nil { 4643 return nil 4644 } 4645 invalidParams := smithy.InvalidParamsError{Context: "DescribeAutomationExecutionsInput"} 4646 if v.Filters != nil { 4647 if err := validateAutomationExecutionFilterList(v.Filters); err != nil { 4648 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 4649 } 4650 } 4651 if invalidParams.Len() > 0 { 4652 return invalidParams 4653 } else { 4654 return nil 4655 } 4656} 4657 4658func validateOpDescribeAutomationStepExecutionsInput(v *DescribeAutomationStepExecutionsInput) error { 4659 if v == nil { 4660 return nil 4661 } 4662 invalidParams := smithy.InvalidParamsError{Context: "DescribeAutomationStepExecutionsInput"} 4663 if v.AutomationExecutionId == nil { 4664 invalidParams.Add(smithy.NewErrParamRequired("AutomationExecutionId")) 4665 } 4666 if v.Filters != nil { 4667 if err := validateStepExecutionFilterList(v.Filters); err != nil { 4668 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 4669 } 4670 } 4671 if invalidParams.Len() > 0 { 4672 return invalidParams 4673 } else { 4674 return nil 4675 } 4676} 4677 4678func validateOpDescribeDocumentInput(v *DescribeDocumentInput) error { 4679 if v == nil { 4680 return nil 4681 } 4682 invalidParams := smithy.InvalidParamsError{Context: "DescribeDocumentInput"} 4683 if v.Name == nil { 4684 invalidParams.Add(smithy.NewErrParamRequired("Name")) 4685 } 4686 if invalidParams.Len() > 0 { 4687 return invalidParams 4688 } else { 4689 return nil 4690 } 4691} 4692 4693func validateOpDescribeDocumentPermissionInput(v *DescribeDocumentPermissionInput) error { 4694 if v == nil { 4695 return nil 4696 } 4697 invalidParams := smithy.InvalidParamsError{Context: "DescribeDocumentPermissionInput"} 4698 if v.Name == nil { 4699 invalidParams.Add(smithy.NewErrParamRequired("Name")) 4700 } 4701 if len(v.PermissionType) == 0 { 4702 invalidParams.Add(smithy.NewErrParamRequired("PermissionType")) 4703 } 4704 if invalidParams.Len() > 0 { 4705 return invalidParams 4706 } else { 4707 return nil 4708 } 4709} 4710 4711func validateOpDescribeEffectiveInstanceAssociationsInput(v *DescribeEffectiveInstanceAssociationsInput) error { 4712 if v == nil { 4713 return nil 4714 } 4715 invalidParams := smithy.InvalidParamsError{Context: "DescribeEffectiveInstanceAssociationsInput"} 4716 if v.InstanceId == nil { 4717 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 4718 } 4719 if invalidParams.Len() > 0 { 4720 return invalidParams 4721 } else { 4722 return nil 4723 } 4724} 4725 4726func validateOpDescribeEffectivePatchesForPatchBaselineInput(v *DescribeEffectivePatchesForPatchBaselineInput) error { 4727 if v == nil { 4728 return nil 4729 } 4730 invalidParams := smithy.InvalidParamsError{Context: "DescribeEffectivePatchesForPatchBaselineInput"} 4731 if v.BaselineId == nil { 4732 invalidParams.Add(smithy.NewErrParamRequired("BaselineId")) 4733 } 4734 if invalidParams.Len() > 0 { 4735 return invalidParams 4736 } else { 4737 return nil 4738 } 4739} 4740 4741func validateOpDescribeInstanceAssociationsStatusInput(v *DescribeInstanceAssociationsStatusInput) error { 4742 if v == nil { 4743 return nil 4744 } 4745 invalidParams := smithy.InvalidParamsError{Context: "DescribeInstanceAssociationsStatusInput"} 4746 if v.InstanceId == nil { 4747 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 4748 } 4749 if invalidParams.Len() > 0 { 4750 return invalidParams 4751 } else { 4752 return nil 4753 } 4754} 4755 4756func validateOpDescribeInstanceInformationInput(v *DescribeInstanceInformationInput) error { 4757 if v == nil { 4758 return nil 4759 } 4760 invalidParams := smithy.InvalidParamsError{Context: "DescribeInstanceInformationInput"} 4761 if v.InstanceInformationFilterList != nil { 4762 if err := validateInstanceInformationFilterList(v.InstanceInformationFilterList); err != nil { 4763 invalidParams.AddNested("InstanceInformationFilterList", err.(smithy.InvalidParamsError)) 4764 } 4765 } 4766 if v.Filters != nil { 4767 if err := validateInstanceInformationStringFilterList(v.Filters); err != nil { 4768 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 4769 } 4770 } 4771 if invalidParams.Len() > 0 { 4772 return invalidParams 4773 } else { 4774 return nil 4775 } 4776} 4777 4778func validateOpDescribeInstancePatchesInput(v *DescribeInstancePatchesInput) error { 4779 if v == nil { 4780 return nil 4781 } 4782 invalidParams := smithy.InvalidParamsError{Context: "DescribeInstancePatchesInput"} 4783 if v.InstanceId == nil { 4784 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 4785 } 4786 if invalidParams.Len() > 0 { 4787 return invalidParams 4788 } else { 4789 return nil 4790 } 4791} 4792 4793func validateOpDescribeInstancePatchStatesForPatchGroupInput(v *DescribeInstancePatchStatesForPatchGroupInput) error { 4794 if v == nil { 4795 return nil 4796 } 4797 invalidParams := smithy.InvalidParamsError{Context: "DescribeInstancePatchStatesForPatchGroupInput"} 4798 if v.PatchGroup == nil { 4799 invalidParams.Add(smithy.NewErrParamRequired("PatchGroup")) 4800 } 4801 if v.Filters != nil { 4802 if err := validateInstancePatchStateFilterList(v.Filters); err != nil { 4803 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 4804 } 4805 } 4806 if invalidParams.Len() > 0 { 4807 return invalidParams 4808 } else { 4809 return nil 4810 } 4811} 4812 4813func validateOpDescribeInstancePatchStatesInput(v *DescribeInstancePatchStatesInput) error { 4814 if v == nil { 4815 return nil 4816 } 4817 invalidParams := smithy.InvalidParamsError{Context: "DescribeInstancePatchStatesInput"} 4818 if v.InstanceIds == nil { 4819 invalidParams.Add(smithy.NewErrParamRequired("InstanceIds")) 4820 } 4821 if invalidParams.Len() > 0 { 4822 return invalidParams 4823 } else { 4824 return nil 4825 } 4826} 4827 4828func validateOpDescribeMaintenanceWindowExecutionsInput(v *DescribeMaintenanceWindowExecutionsInput) error { 4829 if v == nil { 4830 return nil 4831 } 4832 invalidParams := smithy.InvalidParamsError{Context: "DescribeMaintenanceWindowExecutionsInput"} 4833 if v.WindowId == nil { 4834 invalidParams.Add(smithy.NewErrParamRequired("WindowId")) 4835 } 4836 if invalidParams.Len() > 0 { 4837 return invalidParams 4838 } else { 4839 return nil 4840 } 4841} 4842 4843func validateOpDescribeMaintenanceWindowExecutionTaskInvocationsInput(v *DescribeMaintenanceWindowExecutionTaskInvocationsInput) error { 4844 if v == nil { 4845 return nil 4846 } 4847 invalidParams := smithy.InvalidParamsError{Context: "DescribeMaintenanceWindowExecutionTaskInvocationsInput"} 4848 if v.WindowExecutionId == nil { 4849 invalidParams.Add(smithy.NewErrParamRequired("WindowExecutionId")) 4850 } 4851 if v.TaskId == nil { 4852 invalidParams.Add(smithy.NewErrParamRequired("TaskId")) 4853 } 4854 if invalidParams.Len() > 0 { 4855 return invalidParams 4856 } else { 4857 return nil 4858 } 4859} 4860 4861func validateOpDescribeMaintenanceWindowExecutionTasksInput(v *DescribeMaintenanceWindowExecutionTasksInput) error { 4862 if v == nil { 4863 return nil 4864 } 4865 invalidParams := smithy.InvalidParamsError{Context: "DescribeMaintenanceWindowExecutionTasksInput"} 4866 if v.WindowExecutionId == nil { 4867 invalidParams.Add(smithy.NewErrParamRequired("WindowExecutionId")) 4868 } 4869 if invalidParams.Len() > 0 { 4870 return invalidParams 4871 } else { 4872 return nil 4873 } 4874} 4875 4876func validateOpDescribeMaintenanceWindowsForTargetInput(v *DescribeMaintenanceWindowsForTargetInput) error { 4877 if v == nil { 4878 return nil 4879 } 4880 invalidParams := smithy.InvalidParamsError{Context: "DescribeMaintenanceWindowsForTargetInput"} 4881 if v.Targets == nil { 4882 invalidParams.Add(smithy.NewErrParamRequired("Targets")) 4883 } 4884 if len(v.ResourceType) == 0 { 4885 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 4886 } 4887 if invalidParams.Len() > 0 { 4888 return invalidParams 4889 } else { 4890 return nil 4891 } 4892} 4893 4894func validateOpDescribeMaintenanceWindowTargetsInput(v *DescribeMaintenanceWindowTargetsInput) error { 4895 if v == nil { 4896 return nil 4897 } 4898 invalidParams := smithy.InvalidParamsError{Context: "DescribeMaintenanceWindowTargetsInput"} 4899 if v.WindowId == nil { 4900 invalidParams.Add(smithy.NewErrParamRequired("WindowId")) 4901 } 4902 if invalidParams.Len() > 0 { 4903 return invalidParams 4904 } else { 4905 return nil 4906 } 4907} 4908 4909func validateOpDescribeMaintenanceWindowTasksInput(v *DescribeMaintenanceWindowTasksInput) error { 4910 if v == nil { 4911 return nil 4912 } 4913 invalidParams := smithy.InvalidParamsError{Context: "DescribeMaintenanceWindowTasksInput"} 4914 if v.WindowId == nil { 4915 invalidParams.Add(smithy.NewErrParamRequired("WindowId")) 4916 } 4917 if invalidParams.Len() > 0 { 4918 return invalidParams 4919 } else { 4920 return nil 4921 } 4922} 4923 4924func validateOpDescribeOpsItemsInput(v *DescribeOpsItemsInput) error { 4925 if v == nil { 4926 return nil 4927 } 4928 invalidParams := smithy.InvalidParamsError{Context: "DescribeOpsItemsInput"} 4929 if v.OpsItemFilters != nil { 4930 if err := validateOpsItemFilters(v.OpsItemFilters); err != nil { 4931 invalidParams.AddNested("OpsItemFilters", err.(smithy.InvalidParamsError)) 4932 } 4933 } 4934 if invalidParams.Len() > 0 { 4935 return invalidParams 4936 } else { 4937 return nil 4938 } 4939} 4940 4941func validateOpDescribeParametersInput(v *DescribeParametersInput) error { 4942 if v == nil { 4943 return nil 4944 } 4945 invalidParams := smithy.InvalidParamsError{Context: "DescribeParametersInput"} 4946 if v.Filters != nil { 4947 if err := validateParametersFilterList(v.Filters); err != nil { 4948 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 4949 } 4950 } 4951 if v.ParameterFilters != nil { 4952 if err := validateParameterStringFilterList(v.ParameterFilters); err != nil { 4953 invalidParams.AddNested("ParameterFilters", err.(smithy.InvalidParamsError)) 4954 } 4955 } 4956 if invalidParams.Len() > 0 { 4957 return invalidParams 4958 } else { 4959 return nil 4960 } 4961} 4962 4963func validateOpDescribePatchGroupStateInput(v *DescribePatchGroupStateInput) error { 4964 if v == nil { 4965 return nil 4966 } 4967 invalidParams := smithy.InvalidParamsError{Context: "DescribePatchGroupStateInput"} 4968 if v.PatchGroup == nil { 4969 invalidParams.Add(smithy.NewErrParamRequired("PatchGroup")) 4970 } 4971 if invalidParams.Len() > 0 { 4972 return invalidParams 4973 } else { 4974 return nil 4975 } 4976} 4977 4978func validateOpDescribePatchPropertiesInput(v *DescribePatchPropertiesInput) error { 4979 if v == nil { 4980 return nil 4981 } 4982 invalidParams := smithy.InvalidParamsError{Context: "DescribePatchPropertiesInput"} 4983 if len(v.OperatingSystem) == 0 { 4984 invalidParams.Add(smithy.NewErrParamRequired("OperatingSystem")) 4985 } 4986 if len(v.Property) == 0 { 4987 invalidParams.Add(smithy.NewErrParamRequired("Property")) 4988 } 4989 if invalidParams.Len() > 0 { 4990 return invalidParams 4991 } else { 4992 return nil 4993 } 4994} 4995 4996func validateOpDescribeSessionsInput(v *DescribeSessionsInput) error { 4997 if v == nil { 4998 return nil 4999 } 5000 invalidParams := smithy.InvalidParamsError{Context: "DescribeSessionsInput"} 5001 if len(v.State) == 0 { 5002 invalidParams.Add(smithy.NewErrParamRequired("State")) 5003 } 5004 if v.Filters != nil { 5005 if err := validateSessionFilterList(v.Filters); err != nil { 5006 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 5007 } 5008 } 5009 if invalidParams.Len() > 0 { 5010 return invalidParams 5011 } else { 5012 return nil 5013 } 5014} 5015 5016func validateOpGetAutomationExecutionInput(v *GetAutomationExecutionInput) error { 5017 if v == nil { 5018 return nil 5019 } 5020 invalidParams := smithy.InvalidParamsError{Context: "GetAutomationExecutionInput"} 5021 if v.AutomationExecutionId == nil { 5022 invalidParams.Add(smithy.NewErrParamRequired("AutomationExecutionId")) 5023 } 5024 if invalidParams.Len() > 0 { 5025 return invalidParams 5026 } else { 5027 return nil 5028 } 5029} 5030 5031func validateOpGetCalendarStateInput(v *GetCalendarStateInput) error { 5032 if v == nil { 5033 return nil 5034 } 5035 invalidParams := smithy.InvalidParamsError{Context: "GetCalendarStateInput"} 5036 if v.CalendarNames == nil { 5037 invalidParams.Add(smithy.NewErrParamRequired("CalendarNames")) 5038 } 5039 if invalidParams.Len() > 0 { 5040 return invalidParams 5041 } else { 5042 return nil 5043 } 5044} 5045 5046func validateOpGetCommandInvocationInput(v *GetCommandInvocationInput) error { 5047 if v == nil { 5048 return nil 5049 } 5050 invalidParams := smithy.InvalidParamsError{Context: "GetCommandInvocationInput"} 5051 if v.CommandId == nil { 5052 invalidParams.Add(smithy.NewErrParamRequired("CommandId")) 5053 } 5054 if v.InstanceId == nil { 5055 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 5056 } 5057 if invalidParams.Len() > 0 { 5058 return invalidParams 5059 } else { 5060 return nil 5061 } 5062} 5063 5064func validateOpGetConnectionStatusInput(v *GetConnectionStatusInput) error { 5065 if v == nil { 5066 return nil 5067 } 5068 invalidParams := smithy.InvalidParamsError{Context: "GetConnectionStatusInput"} 5069 if v.Target == nil { 5070 invalidParams.Add(smithy.NewErrParamRequired("Target")) 5071 } 5072 if invalidParams.Len() > 0 { 5073 return invalidParams 5074 } else { 5075 return nil 5076 } 5077} 5078 5079func validateOpGetDeployablePatchSnapshotForInstanceInput(v *GetDeployablePatchSnapshotForInstanceInput) error { 5080 if v == nil { 5081 return nil 5082 } 5083 invalidParams := smithy.InvalidParamsError{Context: "GetDeployablePatchSnapshotForInstanceInput"} 5084 if v.InstanceId == nil { 5085 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 5086 } 5087 if v.SnapshotId == nil { 5088 invalidParams.Add(smithy.NewErrParamRequired("SnapshotId")) 5089 } 5090 if invalidParams.Len() > 0 { 5091 return invalidParams 5092 } else { 5093 return nil 5094 } 5095} 5096 5097func validateOpGetDocumentInput(v *GetDocumentInput) error { 5098 if v == nil { 5099 return nil 5100 } 5101 invalidParams := smithy.InvalidParamsError{Context: "GetDocumentInput"} 5102 if v.Name == nil { 5103 invalidParams.Add(smithy.NewErrParamRequired("Name")) 5104 } 5105 if invalidParams.Len() > 0 { 5106 return invalidParams 5107 } else { 5108 return nil 5109 } 5110} 5111 5112func validateOpGetInventoryInput(v *GetInventoryInput) error { 5113 if v == nil { 5114 return nil 5115 } 5116 invalidParams := smithy.InvalidParamsError{Context: "GetInventoryInput"} 5117 if v.Filters != nil { 5118 if err := validateInventoryFilterList(v.Filters); err != nil { 5119 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 5120 } 5121 } 5122 if v.Aggregators != nil { 5123 if err := validateInventoryAggregatorList(v.Aggregators); err != nil { 5124 invalidParams.AddNested("Aggregators", err.(smithy.InvalidParamsError)) 5125 } 5126 } 5127 if v.ResultAttributes != nil { 5128 if err := validateResultAttributeList(v.ResultAttributes); err != nil { 5129 invalidParams.AddNested("ResultAttributes", err.(smithy.InvalidParamsError)) 5130 } 5131 } 5132 if invalidParams.Len() > 0 { 5133 return invalidParams 5134 } else { 5135 return nil 5136 } 5137} 5138 5139func validateOpGetMaintenanceWindowExecutionInput(v *GetMaintenanceWindowExecutionInput) error { 5140 if v == nil { 5141 return nil 5142 } 5143 invalidParams := smithy.InvalidParamsError{Context: "GetMaintenanceWindowExecutionInput"} 5144 if v.WindowExecutionId == nil { 5145 invalidParams.Add(smithy.NewErrParamRequired("WindowExecutionId")) 5146 } 5147 if invalidParams.Len() > 0 { 5148 return invalidParams 5149 } else { 5150 return nil 5151 } 5152} 5153 5154func validateOpGetMaintenanceWindowExecutionTaskInput(v *GetMaintenanceWindowExecutionTaskInput) error { 5155 if v == nil { 5156 return nil 5157 } 5158 invalidParams := smithy.InvalidParamsError{Context: "GetMaintenanceWindowExecutionTaskInput"} 5159 if v.WindowExecutionId == nil { 5160 invalidParams.Add(smithy.NewErrParamRequired("WindowExecutionId")) 5161 } 5162 if v.TaskId == nil { 5163 invalidParams.Add(smithy.NewErrParamRequired("TaskId")) 5164 } 5165 if invalidParams.Len() > 0 { 5166 return invalidParams 5167 } else { 5168 return nil 5169 } 5170} 5171 5172func validateOpGetMaintenanceWindowExecutionTaskInvocationInput(v *GetMaintenanceWindowExecutionTaskInvocationInput) error { 5173 if v == nil { 5174 return nil 5175 } 5176 invalidParams := smithy.InvalidParamsError{Context: "GetMaintenanceWindowExecutionTaskInvocationInput"} 5177 if v.WindowExecutionId == nil { 5178 invalidParams.Add(smithy.NewErrParamRequired("WindowExecutionId")) 5179 } 5180 if v.TaskId == nil { 5181 invalidParams.Add(smithy.NewErrParamRequired("TaskId")) 5182 } 5183 if v.InvocationId == nil { 5184 invalidParams.Add(smithy.NewErrParamRequired("InvocationId")) 5185 } 5186 if invalidParams.Len() > 0 { 5187 return invalidParams 5188 } else { 5189 return nil 5190 } 5191} 5192 5193func validateOpGetMaintenanceWindowInput(v *GetMaintenanceWindowInput) error { 5194 if v == nil { 5195 return nil 5196 } 5197 invalidParams := smithy.InvalidParamsError{Context: "GetMaintenanceWindowInput"} 5198 if v.WindowId == nil { 5199 invalidParams.Add(smithy.NewErrParamRequired("WindowId")) 5200 } 5201 if invalidParams.Len() > 0 { 5202 return invalidParams 5203 } else { 5204 return nil 5205 } 5206} 5207 5208func validateOpGetMaintenanceWindowTaskInput(v *GetMaintenanceWindowTaskInput) error { 5209 if v == nil { 5210 return nil 5211 } 5212 invalidParams := smithy.InvalidParamsError{Context: "GetMaintenanceWindowTaskInput"} 5213 if v.WindowId == nil { 5214 invalidParams.Add(smithy.NewErrParamRequired("WindowId")) 5215 } 5216 if v.WindowTaskId == nil { 5217 invalidParams.Add(smithy.NewErrParamRequired("WindowTaskId")) 5218 } 5219 if invalidParams.Len() > 0 { 5220 return invalidParams 5221 } else { 5222 return nil 5223 } 5224} 5225 5226func validateOpGetOpsItemInput(v *GetOpsItemInput) error { 5227 if v == nil { 5228 return nil 5229 } 5230 invalidParams := smithy.InvalidParamsError{Context: "GetOpsItemInput"} 5231 if v.OpsItemId == nil { 5232 invalidParams.Add(smithy.NewErrParamRequired("OpsItemId")) 5233 } 5234 if invalidParams.Len() > 0 { 5235 return invalidParams 5236 } else { 5237 return nil 5238 } 5239} 5240 5241func validateOpGetOpsMetadataInput(v *GetOpsMetadataInput) error { 5242 if v == nil { 5243 return nil 5244 } 5245 invalidParams := smithy.InvalidParamsError{Context: "GetOpsMetadataInput"} 5246 if v.OpsMetadataArn == nil { 5247 invalidParams.Add(smithy.NewErrParamRequired("OpsMetadataArn")) 5248 } 5249 if invalidParams.Len() > 0 { 5250 return invalidParams 5251 } else { 5252 return nil 5253 } 5254} 5255 5256func validateOpGetOpsSummaryInput(v *GetOpsSummaryInput) error { 5257 if v == nil { 5258 return nil 5259 } 5260 invalidParams := smithy.InvalidParamsError{Context: "GetOpsSummaryInput"} 5261 if v.Filters != nil { 5262 if err := validateOpsFilterList(v.Filters); err != nil { 5263 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 5264 } 5265 } 5266 if v.Aggregators != nil { 5267 if err := validateOpsAggregatorList(v.Aggregators); err != nil { 5268 invalidParams.AddNested("Aggregators", err.(smithy.InvalidParamsError)) 5269 } 5270 } 5271 if v.ResultAttributes != nil { 5272 if err := validateOpsResultAttributeList(v.ResultAttributes); err != nil { 5273 invalidParams.AddNested("ResultAttributes", err.(smithy.InvalidParamsError)) 5274 } 5275 } 5276 if invalidParams.Len() > 0 { 5277 return invalidParams 5278 } else { 5279 return nil 5280 } 5281} 5282 5283func validateOpGetParameterHistoryInput(v *GetParameterHistoryInput) error { 5284 if v == nil { 5285 return nil 5286 } 5287 invalidParams := smithy.InvalidParamsError{Context: "GetParameterHistoryInput"} 5288 if v.Name == nil { 5289 invalidParams.Add(smithy.NewErrParamRequired("Name")) 5290 } 5291 if invalidParams.Len() > 0 { 5292 return invalidParams 5293 } else { 5294 return nil 5295 } 5296} 5297 5298func validateOpGetParameterInput(v *GetParameterInput) error { 5299 if v == nil { 5300 return nil 5301 } 5302 invalidParams := smithy.InvalidParamsError{Context: "GetParameterInput"} 5303 if v.Name == nil { 5304 invalidParams.Add(smithy.NewErrParamRequired("Name")) 5305 } 5306 if invalidParams.Len() > 0 { 5307 return invalidParams 5308 } else { 5309 return nil 5310 } 5311} 5312 5313func validateOpGetParametersByPathInput(v *GetParametersByPathInput) error { 5314 if v == nil { 5315 return nil 5316 } 5317 invalidParams := smithy.InvalidParamsError{Context: "GetParametersByPathInput"} 5318 if v.Path == nil { 5319 invalidParams.Add(smithy.NewErrParamRequired("Path")) 5320 } 5321 if v.ParameterFilters != nil { 5322 if err := validateParameterStringFilterList(v.ParameterFilters); err != nil { 5323 invalidParams.AddNested("ParameterFilters", err.(smithy.InvalidParamsError)) 5324 } 5325 } 5326 if invalidParams.Len() > 0 { 5327 return invalidParams 5328 } else { 5329 return nil 5330 } 5331} 5332 5333func validateOpGetParametersInput(v *GetParametersInput) error { 5334 if v == nil { 5335 return nil 5336 } 5337 invalidParams := smithy.InvalidParamsError{Context: "GetParametersInput"} 5338 if v.Names == nil { 5339 invalidParams.Add(smithy.NewErrParamRequired("Names")) 5340 } 5341 if invalidParams.Len() > 0 { 5342 return invalidParams 5343 } else { 5344 return nil 5345 } 5346} 5347 5348func validateOpGetPatchBaselineForPatchGroupInput(v *GetPatchBaselineForPatchGroupInput) error { 5349 if v == nil { 5350 return nil 5351 } 5352 invalidParams := smithy.InvalidParamsError{Context: "GetPatchBaselineForPatchGroupInput"} 5353 if v.PatchGroup == nil { 5354 invalidParams.Add(smithy.NewErrParamRequired("PatchGroup")) 5355 } 5356 if invalidParams.Len() > 0 { 5357 return invalidParams 5358 } else { 5359 return nil 5360 } 5361} 5362 5363func validateOpGetPatchBaselineInput(v *GetPatchBaselineInput) error { 5364 if v == nil { 5365 return nil 5366 } 5367 invalidParams := smithy.InvalidParamsError{Context: "GetPatchBaselineInput"} 5368 if v.BaselineId == nil { 5369 invalidParams.Add(smithy.NewErrParamRequired("BaselineId")) 5370 } 5371 if invalidParams.Len() > 0 { 5372 return invalidParams 5373 } else { 5374 return nil 5375 } 5376} 5377 5378func validateOpGetServiceSettingInput(v *GetServiceSettingInput) error { 5379 if v == nil { 5380 return nil 5381 } 5382 invalidParams := smithy.InvalidParamsError{Context: "GetServiceSettingInput"} 5383 if v.SettingId == nil { 5384 invalidParams.Add(smithy.NewErrParamRequired("SettingId")) 5385 } 5386 if invalidParams.Len() > 0 { 5387 return invalidParams 5388 } else { 5389 return nil 5390 } 5391} 5392 5393func validateOpLabelParameterVersionInput(v *LabelParameterVersionInput) error { 5394 if v == nil { 5395 return nil 5396 } 5397 invalidParams := smithy.InvalidParamsError{Context: "LabelParameterVersionInput"} 5398 if v.Name == nil { 5399 invalidParams.Add(smithy.NewErrParamRequired("Name")) 5400 } 5401 if v.Labels == nil { 5402 invalidParams.Add(smithy.NewErrParamRequired("Labels")) 5403 } 5404 if invalidParams.Len() > 0 { 5405 return invalidParams 5406 } else { 5407 return nil 5408 } 5409} 5410 5411func validateOpListAssociationsInput(v *ListAssociationsInput) error { 5412 if v == nil { 5413 return nil 5414 } 5415 invalidParams := smithy.InvalidParamsError{Context: "ListAssociationsInput"} 5416 if v.AssociationFilterList != nil { 5417 if err := validateAssociationFilterList(v.AssociationFilterList); err != nil { 5418 invalidParams.AddNested("AssociationFilterList", err.(smithy.InvalidParamsError)) 5419 } 5420 } 5421 if invalidParams.Len() > 0 { 5422 return invalidParams 5423 } else { 5424 return nil 5425 } 5426} 5427 5428func validateOpListAssociationVersionsInput(v *ListAssociationVersionsInput) error { 5429 if v == nil { 5430 return nil 5431 } 5432 invalidParams := smithy.InvalidParamsError{Context: "ListAssociationVersionsInput"} 5433 if v.AssociationId == nil { 5434 invalidParams.Add(smithy.NewErrParamRequired("AssociationId")) 5435 } 5436 if invalidParams.Len() > 0 { 5437 return invalidParams 5438 } else { 5439 return nil 5440 } 5441} 5442 5443func validateOpListCommandInvocationsInput(v *ListCommandInvocationsInput) error { 5444 if v == nil { 5445 return nil 5446 } 5447 invalidParams := smithy.InvalidParamsError{Context: "ListCommandInvocationsInput"} 5448 if v.Filters != nil { 5449 if err := validateCommandFilterList(v.Filters); err != nil { 5450 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 5451 } 5452 } 5453 if invalidParams.Len() > 0 { 5454 return invalidParams 5455 } else { 5456 return nil 5457 } 5458} 5459 5460func validateOpListCommandsInput(v *ListCommandsInput) error { 5461 if v == nil { 5462 return nil 5463 } 5464 invalidParams := smithy.InvalidParamsError{Context: "ListCommandsInput"} 5465 if v.Filters != nil { 5466 if err := validateCommandFilterList(v.Filters); err != nil { 5467 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 5468 } 5469 } 5470 if invalidParams.Len() > 0 { 5471 return invalidParams 5472 } else { 5473 return nil 5474 } 5475} 5476 5477func validateOpListDocumentMetadataHistoryInput(v *ListDocumentMetadataHistoryInput) error { 5478 if v == nil { 5479 return nil 5480 } 5481 invalidParams := smithy.InvalidParamsError{Context: "ListDocumentMetadataHistoryInput"} 5482 if v.Name == nil { 5483 invalidParams.Add(smithy.NewErrParamRequired("Name")) 5484 } 5485 if len(v.Metadata) == 0 { 5486 invalidParams.Add(smithy.NewErrParamRequired("Metadata")) 5487 } 5488 if invalidParams.Len() > 0 { 5489 return invalidParams 5490 } else { 5491 return nil 5492 } 5493} 5494 5495func validateOpListDocumentsInput(v *ListDocumentsInput) error { 5496 if v == nil { 5497 return nil 5498 } 5499 invalidParams := smithy.InvalidParamsError{Context: "ListDocumentsInput"} 5500 if v.DocumentFilterList != nil { 5501 if err := validateDocumentFilterList(v.DocumentFilterList); err != nil { 5502 invalidParams.AddNested("DocumentFilterList", err.(smithy.InvalidParamsError)) 5503 } 5504 } 5505 if invalidParams.Len() > 0 { 5506 return invalidParams 5507 } else { 5508 return nil 5509 } 5510} 5511 5512func validateOpListDocumentVersionsInput(v *ListDocumentVersionsInput) error { 5513 if v == nil { 5514 return nil 5515 } 5516 invalidParams := smithy.InvalidParamsError{Context: "ListDocumentVersionsInput"} 5517 if v.Name == nil { 5518 invalidParams.Add(smithy.NewErrParamRequired("Name")) 5519 } 5520 if invalidParams.Len() > 0 { 5521 return invalidParams 5522 } else { 5523 return nil 5524 } 5525} 5526 5527func validateOpListInventoryEntriesInput(v *ListInventoryEntriesInput) error { 5528 if v == nil { 5529 return nil 5530 } 5531 invalidParams := smithy.InvalidParamsError{Context: "ListInventoryEntriesInput"} 5532 if v.InstanceId == nil { 5533 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 5534 } 5535 if v.TypeName == nil { 5536 invalidParams.Add(smithy.NewErrParamRequired("TypeName")) 5537 } 5538 if v.Filters != nil { 5539 if err := validateInventoryFilterList(v.Filters); err != nil { 5540 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 5541 } 5542 } 5543 if invalidParams.Len() > 0 { 5544 return invalidParams 5545 } else { 5546 return nil 5547 } 5548} 5549 5550func validateOpListOpsItemEventsInput(v *ListOpsItemEventsInput) error { 5551 if v == nil { 5552 return nil 5553 } 5554 invalidParams := smithy.InvalidParamsError{Context: "ListOpsItemEventsInput"} 5555 if v.Filters != nil { 5556 if err := validateOpsItemEventFilters(v.Filters); err != nil { 5557 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 5558 } 5559 } 5560 if invalidParams.Len() > 0 { 5561 return invalidParams 5562 } else { 5563 return nil 5564 } 5565} 5566 5567func validateOpListOpsMetadataInput(v *ListOpsMetadataInput) error { 5568 if v == nil { 5569 return nil 5570 } 5571 invalidParams := smithy.InvalidParamsError{Context: "ListOpsMetadataInput"} 5572 if v.Filters != nil { 5573 if err := validateOpsMetadataFilterList(v.Filters); err != nil { 5574 invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError)) 5575 } 5576 } 5577 if invalidParams.Len() > 0 { 5578 return invalidParams 5579 } else { 5580 return nil 5581 } 5582} 5583 5584func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 5585 if v == nil { 5586 return nil 5587 } 5588 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 5589 if len(v.ResourceType) == 0 { 5590 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 5591 } 5592 if v.ResourceId == nil { 5593 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 5594 } 5595 if invalidParams.Len() > 0 { 5596 return invalidParams 5597 } else { 5598 return nil 5599 } 5600} 5601 5602func validateOpModifyDocumentPermissionInput(v *ModifyDocumentPermissionInput) error { 5603 if v == nil { 5604 return nil 5605 } 5606 invalidParams := smithy.InvalidParamsError{Context: "ModifyDocumentPermissionInput"} 5607 if v.Name == nil { 5608 invalidParams.Add(smithy.NewErrParamRequired("Name")) 5609 } 5610 if len(v.PermissionType) == 0 { 5611 invalidParams.Add(smithy.NewErrParamRequired("PermissionType")) 5612 } 5613 if invalidParams.Len() > 0 { 5614 return invalidParams 5615 } else { 5616 return nil 5617 } 5618} 5619 5620func validateOpPutComplianceItemsInput(v *PutComplianceItemsInput) error { 5621 if v == nil { 5622 return nil 5623 } 5624 invalidParams := smithy.InvalidParamsError{Context: "PutComplianceItemsInput"} 5625 if v.ResourceId == nil { 5626 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 5627 } 5628 if v.ResourceType == nil { 5629 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 5630 } 5631 if v.ComplianceType == nil { 5632 invalidParams.Add(smithy.NewErrParamRequired("ComplianceType")) 5633 } 5634 if v.ExecutionSummary == nil { 5635 invalidParams.Add(smithy.NewErrParamRequired("ExecutionSummary")) 5636 } else if v.ExecutionSummary != nil { 5637 if err := validateComplianceExecutionSummary(v.ExecutionSummary); err != nil { 5638 invalidParams.AddNested("ExecutionSummary", err.(smithy.InvalidParamsError)) 5639 } 5640 } 5641 if v.Items == nil { 5642 invalidParams.Add(smithy.NewErrParamRequired("Items")) 5643 } else if v.Items != nil { 5644 if err := validateComplianceItemEntryList(v.Items); err != nil { 5645 invalidParams.AddNested("Items", err.(smithy.InvalidParamsError)) 5646 } 5647 } 5648 if invalidParams.Len() > 0 { 5649 return invalidParams 5650 } else { 5651 return nil 5652 } 5653} 5654 5655func validateOpPutInventoryInput(v *PutInventoryInput) error { 5656 if v == nil { 5657 return nil 5658 } 5659 invalidParams := smithy.InvalidParamsError{Context: "PutInventoryInput"} 5660 if v.InstanceId == nil { 5661 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 5662 } 5663 if v.Items == nil { 5664 invalidParams.Add(smithy.NewErrParamRequired("Items")) 5665 } else if v.Items != nil { 5666 if err := validateInventoryItemList(v.Items); err != nil { 5667 invalidParams.AddNested("Items", err.(smithy.InvalidParamsError)) 5668 } 5669 } 5670 if invalidParams.Len() > 0 { 5671 return invalidParams 5672 } else { 5673 return nil 5674 } 5675} 5676 5677func validateOpPutParameterInput(v *PutParameterInput) error { 5678 if v == nil { 5679 return nil 5680 } 5681 invalidParams := smithy.InvalidParamsError{Context: "PutParameterInput"} 5682 if v.Name == nil { 5683 invalidParams.Add(smithy.NewErrParamRequired("Name")) 5684 } 5685 if v.Value == nil { 5686 invalidParams.Add(smithy.NewErrParamRequired("Value")) 5687 } 5688 if v.Tags != nil { 5689 if err := validateTagList(v.Tags); err != nil { 5690 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 5691 } 5692 } 5693 if invalidParams.Len() > 0 { 5694 return invalidParams 5695 } else { 5696 return nil 5697 } 5698} 5699 5700func validateOpRegisterDefaultPatchBaselineInput(v *RegisterDefaultPatchBaselineInput) error { 5701 if v == nil { 5702 return nil 5703 } 5704 invalidParams := smithy.InvalidParamsError{Context: "RegisterDefaultPatchBaselineInput"} 5705 if v.BaselineId == nil { 5706 invalidParams.Add(smithy.NewErrParamRequired("BaselineId")) 5707 } 5708 if invalidParams.Len() > 0 { 5709 return invalidParams 5710 } else { 5711 return nil 5712 } 5713} 5714 5715func validateOpRegisterPatchBaselineForPatchGroupInput(v *RegisterPatchBaselineForPatchGroupInput) error { 5716 if v == nil { 5717 return nil 5718 } 5719 invalidParams := smithy.InvalidParamsError{Context: "RegisterPatchBaselineForPatchGroupInput"} 5720 if v.BaselineId == nil { 5721 invalidParams.Add(smithy.NewErrParamRequired("BaselineId")) 5722 } 5723 if v.PatchGroup == nil { 5724 invalidParams.Add(smithy.NewErrParamRequired("PatchGroup")) 5725 } 5726 if invalidParams.Len() > 0 { 5727 return invalidParams 5728 } else { 5729 return nil 5730 } 5731} 5732 5733func validateOpRegisterTargetWithMaintenanceWindowInput(v *RegisterTargetWithMaintenanceWindowInput) error { 5734 if v == nil { 5735 return nil 5736 } 5737 invalidParams := smithy.InvalidParamsError{Context: "RegisterTargetWithMaintenanceWindowInput"} 5738 if v.WindowId == nil { 5739 invalidParams.Add(smithy.NewErrParamRequired("WindowId")) 5740 } 5741 if len(v.ResourceType) == 0 { 5742 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 5743 } 5744 if v.Targets == nil { 5745 invalidParams.Add(smithy.NewErrParamRequired("Targets")) 5746 } 5747 if invalidParams.Len() > 0 { 5748 return invalidParams 5749 } else { 5750 return nil 5751 } 5752} 5753 5754func validateOpRegisterTaskWithMaintenanceWindowInput(v *RegisterTaskWithMaintenanceWindowInput) error { 5755 if v == nil { 5756 return nil 5757 } 5758 invalidParams := smithy.InvalidParamsError{Context: "RegisterTaskWithMaintenanceWindowInput"} 5759 if v.WindowId == nil { 5760 invalidParams.Add(smithy.NewErrParamRequired("WindowId")) 5761 } 5762 if v.TaskArn == nil { 5763 invalidParams.Add(smithy.NewErrParamRequired("TaskArn")) 5764 } 5765 if len(v.TaskType) == 0 { 5766 invalidParams.Add(smithy.NewErrParamRequired("TaskType")) 5767 } 5768 if v.LoggingInfo != nil { 5769 if err := validateLoggingInfo(v.LoggingInfo); err != nil { 5770 invalidParams.AddNested("LoggingInfo", err.(smithy.InvalidParamsError)) 5771 } 5772 } 5773 if invalidParams.Len() > 0 { 5774 return invalidParams 5775 } else { 5776 return nil 5777 } 5778} 5779 5780func validateOpRemoveTagsFromResourceInput(v *RemoveTagsFromResourceInput) error { 5781 if v == nil { 5782 return nil 5783 } 5784 invalidParams := smithy.InvalidParamsError{Context: "RemoveTagsFromResourceInput"} 5785 if len(v.ResourceType) == 0 { 5786 invalidParams.Add(smithy.NewErrParamRequired("ResourceType")) 5787 } 5788 if v.ResourceId == nil { 5789 invalidParams.Add(smithy.NewErrParamRequired("ResourceId")) 5790 } 5791 if v.TagKeys == nil { 5792 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 5793 } 5794 if invalidParams.Len() > 0 { 5795 return invalidParams 5796 } else { 5797 return nil 5798 } 5799} 5800 5801func validateOpResetServiceSettingInput(v *ResetServiceSettingInput) error { 5802 if v == nil { 5803 return nil 5804 } 5805 invalidParams := smithy.InvalidParamsError{Context: "ResetServiceSettingInput"} 5806 if v.SettingId == nil { 5807 invalidParams.Add(smithy.NewErrParamRequired("SettingId")) 5808 } 5809 if invalidParams.Len() > 0 { 5810 return invalidParams 5811 } else { 5812 return nil 5813 } 5814} 5815 5816func validateOpResumeSessionInput(v *ResumeSessionInput) error { 5817 if v == nil { 5818 return nil 5819 } 5820 invalidParams := smithy.InvalidParamsError{Context: "ResumeSessionInput"} 5821 if v.SessionId == nil { 5822 invalidParams.Add(smithy.NewErrParamRequired("SessionId")) 5823 } 5824 if invalidParams.Len() > 0 { 5825 return invalidParams 5826 } else { 5827 return nil 5828 } 5829} 5830 5831func validateOpSendAutomationSignalInput(v *SendAutomationSignalInput) error { 5832 if v == nil { 5833 return nil 5834 } 5835 invalidParams := smithy.InvalidParamsError{Context: "SendAutomationSignalInput"} 5836 if v.AutomationExecutionId == nil { 5837 invalidParams.Add(smithy.NewErrParamRequired("AutomationExecutionId")) 5838 } 5839 if len(v.SignalType) == 0 { 5840 invalidParams.Add(smithy.NewErrParamRequired("SignalType")) 5841 } 5842 if invalidParams.Len() > 0 { 5843 return invalidParams 5844 } else { 5845 return nil 5846 } 5847} 5848 5849func validateOpSendCommandInput(v *SendCommandInput) error { 5850 if v == nil { 5851 return nil 5852 } 5853 invalidParams := smithy.InvalidParamsError{Context: "SendCommandInput"} 5854 if v.DocumentName == nil { 5855 invalidParams.Add(smithy.NewErrParamRequired("DocumentName")) 5856 } 5857 if invalidParams.Len() > 0 { 5858 return invalidParams 5859 } else { 5860 return nil 5861 } 5862} 5863 5864func validateOpStartAssociationsOnceInput(v *StartAssociationsOnceInput) error { 5865 if v == nil { 5866 return nil 5867 } 5868 invalidParams := smithy.InvalidParamsError{Context: "StartAssociationsOnceInput"} 5869 if v.AssociationIds == nil { 5870 invalidParams.Add(smithy.NewErrParamRequired("AssociationIds")) 5871 } 5872 if invalidParams.Len() > 0 { 5873 return invalidParams 5874 } else { 5875 return nil 5876 } 5877} 5878 5879func validateOpStartAutomationExecutionInput(v *StartAutomationExecutionInput) error { 5880 if v == nil { 5881 return nil 5882 } 5883 invalidParams := smithy.InvalidParamsError{Context: "StartAutomationExecutionInput"} 5884 if v.DocumentName == nil { 5885 invalidParams.Add(smithy.NewErrParamRequired("DocumentName")) 5886 } 5887 if v.Tags != nil { 5888 if err := validateTagList(v.Tags); err != nil { 5889 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 5890 } 5891 } 5892 if invalidParams.Len() > 0 { 5893 return invalidParams 5894 } else { 5895 return nil 5896 } 5897} 5898 5899func validateOpStartChangeRequestExecutionInput(v *StartChangeRequestExecutionInput) error { 5900 if v == nil { 5901 return nil 5902 } 5903 invalidParams := smithy.InvalidParamsError{Context: "StartChangeRequestExecutionInput"} 5904 if v.DocumentName == nil { 5905 invalidParams.Add(smithy.NewErrParamRequired("DocumentName")) 5906 } 5907 if v.Runbooks == nil { 5908 invalidParams.Add(smithy.NewErrParamRequired("Runbooks")) 5909 } else if v.Runbooks != nil { 5910 if err := validateRunbooks(v.Runbooks); err != nil { 5911 invalidParams.AddNested("Runbooks", err.(smithy.InvalidParamsError)) 5912 } 5913 } 5914 if v.Tags != nil { 5915 if err := validateTagList(v.Tags); err != nil { 5916 invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError)) 5917 } 5918 } 5919 if invalidParams.Len() > 0 { 5920 return invalidParams 5921 } else { 5922 return nil 5923 } 5924} 5925 5926func validateOpStartSessionInput(v *StartSessionInput) error { 5927 if v == nil { 5928 return nil 5929 } 5930 invalidParams := smithy.InvalidParamsError{Context: "StartSessionInput"} 5931 if v.Target == nil { 5932 invalidParams.Add(smithy.NewErrParamRequired("Target")) 5933 } 5934 if invalidParams.Len() > 0 { 5935 return invalidParams 5936 } else { 5937 return nil 5938 } 5939} 5940 5941func validateOpStopAutomationExecutionInput(v *StopAutomationExecutionInput) error { 5942 if v == nil { 5943 return nil 5944 } 5945 invalidParams := smithy.InvalidParamsError{Context: "StopAutomationExecutionInput"} 5946 if v.AutomationExecutionId == nil { 5947 invalidParams.Add(smithy.NewErrParamRequired("AutomationExecutionId")) 5948 } 5949 if invalidParams.Len() > 0 { 5950 return invalidParams 5951 } else { 5952 return nil 5953 } 5954} 5955 5956func validateOpTerminateSessionInput(v *TerminateSessionInput) error { 5957 if v == nil { 5958 return nil 5959 } 5960 invalidParams := smithy.InvalidParamsError{Context: "TerminateSessionInput"} 5961 if v.SessionId == nil { 5962 invalidParams.Add(smithy.NewErrParamRequired("SessionId")) 5963 } 5964 if invalidParams.Len() > 0 { 5965 return invalidParams 5966 } else { 5967 return nil 5968 } 5969} 5970 5971func validateOpUpdateAssociationInput(v *UpdateAssociationInput) error { 5972 if v == nil { 5973 return nil 5974 } 5975 invalidParams := smithy.InvalidParamsError{Context: "UpdateAssociationInput"} 5976 if v.AssociationId == nil { 5977 invalidParams.Add(smithy.NewErrParamRequired("AssociationId")) 5978 } 5979 if invalidParams.Len() > 0 { 5980 return invalidParams 5981 } else { 5982 return nil 5983 } 5984} 5985 5986func validateOpUpdateAssociationStatusInput(v *UpdateAssociationStatusInput) error { 5987 if v == nil { 5988 return nil 5989 } 5990 invalidParams := smithy.InvalidParamsError{Context: "UpdateAssociationStatusInput"} 5991 if v.Name == nil { 5992 invalidParams.Add(smithy.NewErrParamRequired("Name")) 5993 } 5994 if v.InstanceId == nil { 5995 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 5996 } 5997 if v.AssociationStatus == nil { 5998 invalidParams.Add(smithy.NewErrParamRequired("AssociationStatus")) 5999 } else if v.AssociationStatus != nil { 6000 if err := validateAssociationStatus(v.AssociationStatus); err != nil { 6001 invalidParams.AddNested("AssociationStatus", err.(smithy.InvalidParamsError)) 6002 } 6003 } 6004 if invalidParams.Len() > 0 { 6005 return invalidParams 6006 } else { 6007 return nil 6008 } 6009} 6010 6011func validateOpUpdateDocumentDefaultVersionInput(v *UpdateDocumentDefaultVersionInput) error { 6012 if v == nil { 6013 return nil 6014 } 6015 invalidParams := smithy.InvalidParamsError{Context: "UpdateDocumentDefaultVersionInput"} 6016 if v.Name == nil { 6017 invalidParams.Add(smithy.NewErrParamRequired("Name")) 6018 } 6019 if v.DocumentVersion == nil { 6020 invalidParams.Add(smithy.NewErrParamRequired("DocumentVersion")) 6021 } 6022 if invalidParams.Len() > 0 { 6023 return invalidParams 6024 } else { 6025 return nil 6026 } 6027} 6028 6029func validateOpUpdateDocumentInput(v *UpdateDocumentInput) error { 6030 if v == nil { 6031 return nil 6032 } 6033 invalidParams := smithy.InvalidParamsError{Context: "UpdateDocumentInput"} 6034 if v.Content == nil { 6035 invalidParams.Add(smithy.NewErrParamRequired("Content")) 6036 } 6037 if v.Name == nil { 6038 invalidParams.Add(smithy.NewErrParamRequired("Name")) 6039 } 6040 if invalidParams.Len() > 0 { 6041 return invalidParams 6042 } else { 6043 return nil 6044 } 6045} 6046 6047func validateOpUpdateDocumentMetadataInput(v *UpdateDocumentMetadataInput) error { 6048 if v == nil { 6049 return nil 6050 } 6051 invalidParams := smithy.InvalidParamsError{Context: "UpdateDocumentMetadataInput"} 6052 if v.Name == nil { 6053 invalidParams.Add(smithy.NewErrParamRequired("Name")) 6054 } 6055 if v.DocumentReviews == nil { 6056 invalidParams.Add(smithy.NewErrParamRequired("DocumentReviews")) 6057 } else if v.DocumentReviews != nil { 6058 if err := validateDocumentReviews(v.DocumentReviews); err != nil { 6059 invalidParams.AddNested("DocumentReviews", err.(smithy.InvalidParamsError)) 6060 } 6061 } 6062 if invalidParams.Len() > 0 { 6063 return invalidParams 6064 } else { 6065 return nil 6066 } 6067} 6068 6069func validateOpUpdateMaintenanceWindowInput(v *UpdateMaintenanceWindowInput) error { 6070 if v == nil { 6071 return nil 6072 } 6073 invalidParams := smithy.InvalidParamsError{Context: "UpdateMaintenanceWindowInput"} 6074 if v.WindowId == nil { 6075 invalidParams.Add(smithy.NewErrParamRequired("WindowId")) 6076 } 6077 if invalidParams.Len() > 0 { 6078 return invalidParams 6079 } else { 6080 return nil 6081 } 6082} 6083 6084func validateOpUpdateMaintenanceWindowTargetInput(v *UpdateMaintenanceWindowTargetInput) error { 6085 if v == nil { 6086 return nil 6087 } 6088 invalidParams := smithy.InvalidParamsError{Context: "UpdateMaintenanceWindowTargetInput"} 6089 if v.WindowId == nil { 6090 invalidParams.Add(smithy.NewErrParamRequired("WindowId")) 6091 } 6092 if v.WindowTargetId == nil { 6093 invalidParams.Add(smithy.NewErrParamRequired("WindowTargetId")) 6094 } 6095 if invalidParams.Len() > 0 { 6096 return invalidParams 6097 } else { 6098 return nil 6099 } 6100} 6101 6102func validateOpUpdateMaintenanceWindowTaskInput(v *UpdateMaintenanceWindowTaskInput) error { 6103 if v == nil { 6104 return nil 6105 } 6106 invalidParams := smithy.InvalidParamsError{Context: "UpdateMaintenanceWindowTaskInput"} 6107 if v.WindowId == nil { 6108 invalidParams.Add(smithy.NewErrParamRequired("WindowId")) 6109 } 6110 if v.WindowTaskId == nil { 6111 invalidParams.Add(smithy.NewErrParamRequired("WindowTaskId")) 6112 } 6113 if v.LoggingInfo != nil { 6114 if err := validateLoggingInfo(v.LoggingInfo); err != nil { 6115 invalidParams.AddNested("LoggingInfo", err.(smithy.InvalidParamsError)) 6116 } 6117 } 6118 if invalidParams.Len() > 0 { 6119 return invalidParams 6120 } else { 6121 return nil 6122 } 6123} 6124 6125func validateOpUpdateManagedInstanceRoleInput(v *UpdateManagedInstanceRoleInput) error { 6126 if v == nil { 6127 return nil 6128 } 6129 invalidParams := smithy.InvalidParamsError{Context: "UpdateManagedInstanceRoleInput"} 6130 if v.InstanceId == nil { 6131 invalidParams.Add(smithy.NewErrParamRequired("InstanceId")) 6132 } 6133 if v.IamRole == nil { 6134 invalidParams.Add(smithy.NewErrParamRequired("IamRole")) 6135 } 6136 if invalidParams.Len() > 0 { 6137 return invalidParams 6138 } else { 6139 return nil 6140 } 6141} 6142 6143func validateOpUpdateOpsItemInput(v *UpdateOpsItemInput) error { 6144 if v == nil { 6145 return nil 6146 } 6147 invalidParams := smithy.InvalidParamsError{Context: "UpdateOpsItemInput"} 6148 if v.RelatedOpsItems != nil { 6149 if err := validateRelatedOpsItems(v.RelatedOpsItems); err != nil { 6150 invalidParams.AddNested("RelatedOpsItems", err.(smithy.InvalidParamsError)) 6151 } 6152 } 6153 if v.OpsItemId == nil { 6154 invalidParams.Add(smithy.NewErrParamRequired("OpsItemId")) 6155 } 6156 if invalidParams.Len() > 0 { 6157 return invalidParams 6158 } else { 6159 return nil 6160 } 6161} 6162 6163func validateOpUpdateOpsMetadataInput(v *UpdateOpsMetadataInput) error { 6164 if v == nil { 6165 return nil 6166 } 6167 invalidParams := smithy.InvalidParamsError{Context: "UpdateOpsMetadataInput"} 6168 if v.OpsMetadataArn == nil { 6169 invalidParams.Add(smithy.NewErrParamRequired("OpsMetadataArn")) 6170 } 6171 if invalidParams.Len() > 0 { 6172 return invalidParams 6173 } else { 6174 return nil 6175 } 6176} 6177 6178func validateOpUpdatePatchBaselineInput(v *UpdatePatchBaselineInput) error { 6179 if v == nil { 6180 return nil 6181 } 6182 invalidParams := smithy.InvalidParamsError{Context: "UpdatePatchBaselineInput"} 6183 if v.BaselineId == nil { 6184 invalidParams.Add(smithy.NewErrParamRequired("BaselineId")) 6185 } 6186 if v.GlobalFilters != nil { 6187 if err := validatePatchFilterGroup(v.GlobalFilters); err != nil { 6188 invalidParams.AddNested("GlobalFilters", err.(smithy.InvalidParamsError)) 6189 } 6190 } 6191 if v.ApprovalRules != nil { 6192 if err := validatePatchRuleGroup(v.ApprovalRules); err != nil { 6193 invalidParams.AddNested("ApprovalRules", err.(smithy.InvalidParamsError)) 6194 } 6195 } 6196 if v.Sources != nil { 6197 if err := validatePatchSourceList(v.Sources); err != nil { 6198 invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError)) 6199 } 6200 } 6201 if invalidParams.Len() > 0 { 6202 return invalidParams 6203 } else { 6204 return nil 6205 } 6206} 6207 6208func validateOpUpdateResourceDataSyncInput(v *UpdateResourceDataSyncInput) error { 6209 if v == nil { 6210 return nil 6211 } 6212 invalidParams := smithy.InvalidParamsError{Context: "UpdateResourceDataSyncInput"} 6213 if v.SyncName == nil { 6214 invalidParams.Add(smithy.NewErrParamRequired("SyncName")) 6215 } 6216 if v.SyncType == nil { 6217 invalidParams.Add(smithy.NewErrParamRequired("SyncType")) 6218 } 6219 if v.SyncSource == nil { 6220 invalidParams.Add(smithy.NewErrParamRequired("SyncSource")) 6221 } else if v.SyncSource != nil { 6222 if err := validateResourceDataSyncSource(v.SyncSource); err != nil { 6223 invalidParams.AddNested("SyncSource", err.(smithy.InvalidParamsError)) 6224 } 6225 } 6226 if invalidParams.Len() > 0 { 6227 return invalidParams 6228 } else { 6229 return nil 6230 } 6231} 6232 6233func validateOpUpdateServiceSettingInput(v *UpdateServiceSettingInput) error { 6234 if v == nil { 6235 return nil 6236 } 6237 invalidParams := smithy.InvalidParamsError{Context: "UpdateServiceSettingInput"} 6238 if v.SettingId == nil { 6239 invalidParams.Add(smithy.NewErrParamRequired("SettingId")) 6240 } 6241 if v.SettingValue == nil { 6242 invalidParams.Add(smithy.NewErrParamRequired("SettingValue")) 6243 } 6244 if invalidParams.Len() > 0 { 6245 return invalidParams 6246 } else { 6247 return nil 6248 } 6249} 6250