1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package backup 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/backup/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpCreateBackupPlan struct { 14} 15 16func (*validateOpCreateBackupPlan) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpCreateBackupPlan) 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.(*CreateBackupPlanInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpCreateBackupPlanInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpCreateBackupSelection struct { 34} 35 36func (*validateOpCreateBackupSelection) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpCreateBackupSelection) 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.(*CreateBackupSelectionInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpCreateBackupSelectionInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpCreateBackupVault struct { 54} 55 56func (*validateOpCreateBackupVault) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpCreateBackupVault) 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.(*CreateBackupVaultInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpCreateBackupVaultInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCreateFramework struct { 74} 75 76func (*validateOpCreateFramework) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCreateFramework) 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.(*CreateFrameworkInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCreateFrameworkInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCreateReportPlan struct { 94} 95 96func (*validateOpCreateReportPlan) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCreateReportPlan) 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.(*CreateReportPlanInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCreateReportPlanInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpDeleteBackupPlan struct { 114} 115 116func (*validateOpDeleteBackupPlan) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpDeleteBackupPlan) 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.(*DeleteBackupPlanInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpDeleteBackupPlanInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDeleteBackupSelection struct { 134} 135 136func (*validateOpDeleteBackupSelection) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDeleteBackupSelection) 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.(*DeleteBackupSelectionInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDeleteBackupSelectionInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeleteBackupVaultAccessPolicy struct { 154} 155 156func (*validateOpDeleteBackupVaultAccessPolicy) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeleteBackupVaultAccessPolicy) 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.(*DeleteBackupVaultAccessPolicyInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeleteBackupVaultAccessPolicyInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDeleteBackupVault struct { 174} 175 176func (*validateOpDeleteBackupVault) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDeleteBackupVault) 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.(*DeleteBackupVaultInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDeleteBackupVaultInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDeleteBackupVaultNotifications struct { 194} 195 196func (*validateOpDeleteBackupVaultNotifications) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDeleteBackupVaultNotifications) 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.(*DeleteBackupVaultNotificationsInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDeleteBackupVaultNotificationsInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDeleteFramework struct { 214} 215 216func (*validateOpDeleteFramework) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDeleteFramework) 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.(*DeleteFrameworkInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDeleteFrameworkInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDeleteRecoveryPoint struct { 234} 235 236func (*validateOpDeleteRecoveryPoint) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDeleteRecoveryPoint) 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.(*DeleteRecoveryPointInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDeleteRecoveryPointInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpDeleteReportPlan struct { 254} 255 256func (*validateOpDeleteReportPlan) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpDeleteReportPlan) 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.(*DeleteReportPlanInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpDeleteReportPlanInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpDescribeBackupJob struct { 274} 275 276func (*validateOpDescribeBackupJob) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpDescribeBackupJob) 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.(*DescribeBackupJobInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpDescribeBackupJobInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpDescribeBackupVault struct { 294} 295 296func (*validateOpDescribeBackupVault) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpDescribeBackupVault) 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.(*DescribeBackupVaultInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpDescribeBackupVaultInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpDescribeCopyJob struct { 314} 315 316func (*validateOpDescribeCopyJob) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpDescribeCopyJob) 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.(*DescribeCopyJobInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpDescribeCopyJobInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpDescribeFramework struct { 334} 335 336func (*validateOpDescribeFramework) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpDescribeFramework) 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.(*DescribeFrameworkInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpDescribeFrameworkInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpDescribeProtectedResource struct { 354} 355 356func (*validateOpDescribeProtectedResource) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpDescribeProtectedResource) 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.(*DescribeProtectedResourceInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpDescribeProtectedResourceInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpDescribeRecoveryPoint struct { 374} 375 376func (*validateOpDescribeRecoveryPoint) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpDescribeRecoveryPoint) 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.(*DescribeRecoveryPointInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpDescribeRecoveryPointInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpDescribeReportJob struct { 394} 395 396func (*validateOpDescribeReportJob) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpDescribeReportJob) 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.(*DescribeReportJobInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpDescribeReportJobInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpDescribeReportPlan struct { 414} 415 416func (*validateOpDescribeReportPlan) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpDescribeReportPlan) 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.(*DescribeReportPlanInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpDescribeReportPlanInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpDescribeRestoreJob struct { 434} 435 436func (*validateOpDescribeRestoreJob) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpDescribeRestoreJob) 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.(*DescribeRestoreJobInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpDescribeRestoreJobInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpDisassociateRecoveryPoint struct { 454} 455 456func (*validateOpDisassociateRecoveryPoint) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpDisassociateRecoveryPoint) 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.(*DisassociateRecoveryPointInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpDisassociateRecoveryPointInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpExportBackupPlanTemplate struct { 474} 475 476func (*validateOpExportBackupPlanTemplate) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpExportBackupPlanTemplate) 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.(*ExportBackupPlanTemplateInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpExportBackupPlanTemplateInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpGetBackupPlanFromJSON struct { 494} 495 496func (*validateOpGetBackupPlanFromJSON) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpGetBackupPlanFromJSON) 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.(*GetBackupPlanFromJSONInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpGetBackupPlanFromJSONInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpGetBackupPlanFromTemplate struct { 514} 515 516func (*validateOpGetBackupPlanFromTemplate) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpGetBackupPlanFromTemplate) 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.(*GetBackupPlanFromTemplateInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpGetBackupPlanFromTemplateInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpGetBackupPlan struct { 534} 535 536func (*validateOpGetBackupPlan) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpGetBackupPlan) 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.(*GetBackupPlanInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpGetBackupPlanInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpGetBackupSelection struct { 554} 555 556func (*validateOpGetBackupSelection) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpGetBackupSelection) 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.(*GetBackupSelectionInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpGetBackupSelectionInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpGetBackupVaultAccessPolicy struct { 574} 575 576func (*validateOpGetBackupVaultAccessPolicy) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpGetBackupVaultAccessPolicy) 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.(*GetBackupVaultAccessPolicyInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpGetBackupVaultAccessPolicyInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpGetBackupVaultNotifications struct { 594} 595 596func (*validateOpGetBackupVaultNotifications) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpGetBackupVaultNotifications) 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.(*GetBackupVaultNotificationsInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpGetBackupVaultNotificationsInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpGetRecoveryPointRestoreMetadata struct { 614} 615 616func (*validateOpGetRecoveryPointRestoreMetadata) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpGetRecoveryPointRestoreMetadata) 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.(*GetRecoveryPointRestoreMetadataInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpGetRecoveryPointRestoreMetadataInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpListBackupPlanVersions struct { 634} 635 636func (*validateOpListBackupPlanVersions) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpListBackupPlanVersions) 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.(*ListBackupPlanVersionsInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpListBackupPlanVersionsInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpListBackupSelections struct { 654} 655 656func (*validateOpListBackupSelections) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpListBackupSelections) 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.(*ListBackupSelectionsInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpListBackupSelectionsInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpListRecoveryPointsByBackupVault struct { 674} 675 676func (*validateOpListRecoveryPointsByBackupVault) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpListRecoveryPointsByBackupVault) 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.(*ListRecoveryPointsByBackupVaultInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpListRecoveryPointsByBackupVaultInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpListRecoveryPointsByResource struct { 694} 695 696func (*validateOpListRecoveryPointsByResource) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpListRecoveryPointsByResource) 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.(*ListRecoveryPointsByResourceInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpListRecoveryPointsByResourceInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpListTags struct { 714} 715 716func (*validateOpListTags) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpListTags) 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.(*ListTagsInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpListTagsInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpPutBackupVaultAccessPolicy struct { 734} 735 736func (*validateOpPutBackupVaultAccessPolicy) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpPutBackupVaultAccessPolicy) 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.(*PutBackupVaultAccessPolicyInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpPutBackupVaultAccessPolicyInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753type validateOpPutBackupVaultNotifications struct { 754} 755 756func (*validateOpPutBackupVaultNotifications) ID() string { 757 return "OperationInputValidation" 758} 759 760func (m *validateOpPutBackupVaultNotifications) 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.(*PutBackupVaultNotificationsInput) 764 if !ok { 765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 766 } 767 if err := validateOpPutBackupVaultNotificationsInput(input); err != nil { 768 return out, metadata, err 769 } 770 return next.HandleInitialize(ctx, in) 771} 772 773type validateOpStartBackupJob struct { 774} 775 776func (*validateOpStartBackupJob) ID() string { 777 return "OperationInputValidation" 778} 779 780func (m *validateOpStartBackupJob) 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.(*StartBackupJobInput) 784 if !ok { 785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 786 } 787 if err := validateOpStartBackupJobInput(input); err != nil { 788 return out, metadata, err 789 } 790 return next.HandleInitialize(ctx, in) 791} 792 793type validateOpStartCopyJob struct { 794} 795 796func (*validateOpStartCopyJob) ID() string { 797 return "OperationInputValidation" 798} 799 800func (m *validateOpStartCopyJob) 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.(*StartCopyJobInput) 804 if !ok { 805 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 806 } 807 if err := validateOpStartCopyJobInput(input); err != nil { 808 return out, metadata, err 809 } 810 return next.HandleInitialize(ctx, in) 811} 812 813type validateOpStartReportJob struct { 814} 815 816func (*validateOpStartReportJob) ID() string { 817 return "OperationInputValidation" 818} 819 820func (m *validateOpStartReportJob) 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.(*StartReportJobInput) 824 if !ok { 825 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 826 } 827 if err := validateOpStartReportJobInput(input); err != nil { 828 return out, metadata, err 829 } 830 return next.HandleInitialize(ctx, in) 831} 832 833type validateOpStartRestoreJob struct { 834} 835 836func (*validateOpStartRestoreJob) ID() string { 837 return "OperationInputValidation" 838} 839 840func (m *validateOpStartRestoreJob) 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.(*StartRestoreJobInput) 844 if !ok { 845 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 846 } 847 if err := validateOpStartRestoreJobInput(input); err != nil { 848 return out, metadata, err 849 } 850 return next.HandleInitialize(ctx, in) 851} 852 853type validateOpStopBackupJob struct { 854} 855 856func (*validateOpStopBackupJob) ID() string { 857 return "OperationInputValidation" 858} 859 860func (m *validateOpStopBackupJob) 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.(*StopBackupJobInput) 864 if !ok { 865 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 866 } 867 if err := validateOpStopBackupJobInput(input); err != nil { 868 return out, metadata, err 869 } 870 return next.HandleInitialize(ctx, in) 871} 872 873type validateOpTagResource struct { 874} 875 876func (*validateOpTagResource) ID() string { 877 return "OperationInputValidation" 878} 879 880func (m *validateOpTagResource) 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.(*TagResourceInput) 884 if !ok { 885 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 886 } 887 if err := validateOpTagResourceInput(input); err != nil { 888 return out, metadata, err 889 } 890 return next.HandleInitialize(ctx, in) 891} 892 893type validateOpUntagResource struct { 894} 895 896func (*validateOpUntagResource) ID() string { 897 return "OperationInputValidation" 898} 899 900func (m *validateOpUntagResource) 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.(*UntagResourceInput) 904 if !ok { 905 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 906 } 907 if err := validateOpUntagResourceInput(input); err != nil { 908 return out, metadata, err 909 } 910 return next.HandleInitialize(ctx, in) 911} 912 913type validateOpUpdateBackupPlan struct { 914} 915 916func (*validateOpUpdateBackupPlan) ID() string { 917 return "OperationInputValidation" 918} 919 920func (m *validateOpUpdateBackupPlan) 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.(*UpdateBackupPlanInput) 924 if !ok { 925 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 926 } 927 if err := validateOpUpdateBackupPlanInput(input); err != nil { 928 return out, metadata, err 929 } 930 return next.HandleInitialize(ctx, in) 931} 932 933type validateOpUpdateFramework struct { 934} 935 936func (*validateOpUpdateFramework) ID() string { 937 return "OperationInputValidation" 938} 939 940func (m *validateOpUpdateFramework) 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.(*UpdateFrameworkInput) 944 if !ok { 945 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 946 } 947 if err := validateOpUpdateFrameworkInput(input); err != nil { 948 return out, metadata, err 949 } 950 return next.HandleInitialize(ctx, in) 951} 952 953type validateOpUpdateRecoveryPointLifecycle struct { 954} 955 956func (*validateOpUpdateRecoveryPointLifecycle) ID() string { 957 return "OperationInputValidation" 958} 959 960func (m *validateOpUpdateRecoveryPointLifecycle) 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.(*UpdateRecoveryPointLifecycleInput) 964 if !ok { 965 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 966 } 967 if err := validateOpUpdateRecoveryPointLifecycleInput(input); err != nil { 968 return out, metadata, err 969 } 970 return next.HandleInitialize(ctx, in) 971} 972 973type validateOpUpdateReportPlan struct { 974} 975 976func (*validateOpUpdateReportPlan) ID() string { 977 return "OperationInputValidation" 978} 979 980func (m *validateOpUpdateReportPlan) 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.(*UpdateReportPlanInput) 984 if !ok { 985 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 986 } 987 if err := validateOpUpdateReportPlanInput(input); err != nil { 988 return out, metadata, err 989 } 990 return next.HandleInitialize(ctx, in) 991} 992 993func addOpCreateBackupPlanValidationMiddleware(stack *middleware.Stack) error { 994 return stack.Initialize.Add(&validateOpCreateBackupPlan{}, middleware.After) 995} 996 997func addOpCreateBackupSelectionValidationMiddleware(stack *middleware.Stack) error { 998 return stack.Initialize.Add(&validateOpCreateBackupSelection{}, middleware.After) 999} 1000 1001func addOpCreateBackupVaultValidationMiddleware(stack *middleware.Stack) error { 1002 return stack.Initialize.Add(&validateOpCreateBackupVault{}, middleware.After) 1003} 1004 1005func addOpCreateFrameworkValidationMiddleware(stack *middleware.Stack) error { 1006 return stack.Initialize.Add(&validateOpCreateFramework{}, middleware.After) 1007} 1008 1009func addOpCreateReportPlanValidationMiddleware(stack *middleware.Stack) error { 1010 return stack.Initialize.Add(&validateOpCreateReportPlan{}, middleware.After) 1011} 1012 1013func addOpDeleteBackupPlanValidationMiddleware(stack *middleware.Stack) error { 1014 return stack.Initialize.Add(&validateOpDeleteBackupPlan{}, middleware.After) 1015} 1016 1017func addOpDeleteBackupSelectionValidationMiddleware(stack *middleware.Stack) error { 1018 return stack.Initialize.Add(&validateOpDeleteBackupSelection{}, middleware.After) 1019} 1020 1021func addOpDeleteBackupVaultAccessPolicyValidationMiddleware(stack *middleware.Stack) error { 1022 return stack.Initialize.Add(&validateOpDeleteBackupVaultAccessPolicy{}, middleware.After) 1023} 1024 1025func addOpDeleteBackupVaultValidationMiddleware(stack *middleware.Stack) error { 1026 return stack.Initialize.Add(&validateOpDeleteBackupVault{}, middleware.After) 1027} 1028 1029func addOpDeleteBackupVaultNotificationsValidationMiddleware(stack *middleware.Stack) error { 1030 return stack.Initialize.Add(&validateOpDeleteBackupVaultNotifications{}, middleware.After) 1031} 1032 1033func addOpDeleteFrameworkValidationMiddleware(stack *middleware.Stack) error { 1034 return stack.Initialize.Add(&validateOpDeleteFramework{}, middleware.After) 1035} 1036 1037func addOpDeleteRecoveryPointValidationMiddleware(stack *middleware.Stack) error { 1038 return stack.Initialize.Add(&validateOpDeleteRecoveryPoint{}, middleware.After) 1039} 1040 1041func addOpDeleteReportPlanValidationMiddleware(stack *middleware.Stack) error { 1042 return stack.Initialize.Add(&validateOpDeleteReportPlan{}, middleware.After) 1043} 1044 1045func addOpDescribeBackupJobValidationMiddleware(stack *middleware.Stack) error { 1046 return stack.Initialize.Add(&validateOpDescribeBackupJob{}, middleware.After) 1047} 1048 1049func addOpDescribeBackupVaultValidationMiddleware(stack *middleware.Stack) error { 1050 return stack.Initialize.Add(&validateOpDescribeBackupVault{}, middleware.After) 1051} 1052 1053func addOpDescribeCopyJobValidationMiddleware(stack *middleware.Stack) error { 1054 return stack.Initialize.Add(&validateOpDescribeCopyJob{}, middleware.After) 1055} 1056 1057func addOpDescribeFrameworkValidationMiddleware(stack *middleware.Stack) error { 1058 return stack.Initialize.Add(&validateOpDescribeFramework{}, middleware.After) 1059} 1060 1061func addOpDescribeProtectedResourceValidationMiddleware(stack *middleware.Stack) error { 1062 return stack.Initialize.Add(&validateOpDescribeProtectedResource{}, middleware.After) 1063} 1064 1065func addOpDescribeRecoveryPointValidationMiddleware(stack *middleware.Stack) error { 1066 return stack.Initialize.Add(&validateOpDescribeRecoveryPoint{}, middleware.After) 1067} 1068 1069func addOpDescribeReportJobValidationMiddleware(stack *middleware.Stack) error { 1070 return stack.Initialize.Add(&validateOpDescribeReportJob{}, middleware.After) 1071} 1072 1073func addOpDescribeReportPlanValidationMiddleware(stack *middleware.Stack) error { 1074 return stack.Initialize.Add(&validateOpDescribeReportPlan{}, middleware.After) 1075} 1076 1077func addOpDescribeRestoreJobValidationMiddleware(stack *middleware.Stack) error { 1078 return stack.Initialize.Add(&validateOpDescribeRestoreJob{}, middleware.After) 1079} 1080 1081func addOpDisassociateRecoveryPointValidationMiddleware(stack *middleware.Stack) error { 1082 return stack.Initialize.Add(&validateOpDisassociateRecoveryPoint{}, middleware.After) 1083} 1084 1085func addOpExportBackupPlanTemplateValidationMiddleware(stack *middleware.Stack) error { 1086 return stack.Initialize.Add(&validateOpExportBackupPlanTemplate{}, middleware.After) 1087} 1088 1089func addOpGetBackupPlanFromJSONValidationMiddleware(stack *middleware.Stack) error { 1090 return stack.Initialize.Add(&validateOpGetBackupPlanFromJSON{}, middleware.After) 1091} 1092 1093func addOpGetBackupPlanFromTemplateValidationMiddleware(stack *middleware.Stack) error { 1094 return stack.Initialize.Add(&validateOpGetBackupPlanFromTemplate{}, middleware.After) 1095} 1096 1097func addOpGetBackupPlanValidationMiddleware(stack *middleware.Stack) error { 1098 return stack.Initialize.Add(&validateOpGetBackupPlan{}, middleware.After) 1099} 1100 1101func addOpGetBackupSelectionValidationMiddleware(stack *middleware.Stack) error { 1102 return stack.Initialize.Add(&validateOpGetBackupSelection{}, middleware.After) 1103} 1104 1105func addOpGetBackupVaultAccessPolicyValidationMiddleware(stack *middleware.Stack) error { 1106 return stack.Initialize.Add(&validateOpGetBackupVaultAccessPolicy{}, middleware.After) 1107} 1108 1109func addOpGetBackupVaultNotificationsValidationMiddleware(stack *middleware.Stack) error { 1110 return stack.Initialize.Add(&validateOpGetBackupVaultNotifications{}, middleware.After) 1111} 1112 1113func addOpGetRecoveryPointRestoreMetadataValidationMiddleware(stack *middleware.Stack) error { 1114 return stack.Initialize.Add(&validateOpGetRecoveryPointRestoreMetadata{}, middleware.After) 1115} 1116 1117func addOpListBackupPlanVersionsValidationMiddleware(stack *middleware.Stack) error { 1118 return stack.Initialize.Add(&validateOpListBackupPlanVersions{}, middleware.After) 1119} 1120 1121func addOpListBackupSelectionsValidationMiddleware(stack *middleware.Stack) error { 1122 return stack.Initialize.Add(&validateOpListBackupSelections{}, middleware.After) 1123} 1124 1125func addOpListRecoveryPointsByBackupVaultValidationMiddleware(stack *middleware.Stack) error { 1126 return stack.Initialize.Add(&validateOpListRecoveryPointsByBackupVault{}, middleware.After) 1127} 1128 1129func addOpListRecoveryPointsByResourceValidationMiddleware(stack *middleware.Stack) error { 1130 return stack.Initialize.Add(&validateOpListRecoveryPointsByResource{}, middleware.After) 1131} 1132 1133func addOpListTagsValidationMiddleware(stack *middleware.Stack) error { 1134 return stack.Initialize.Add(&validateOpListTags{}, middleware.After) 1135} 1136 1137func addOpPutBackupVaultAccessPolicyValidationMiddleware(stack *middleware.Stack) error { 1138 return stack.Initialize.Add(&validateOpPutBackupVaultAccessPolicy{}, middleware.After) 1139} 1140 1141func addOpPutBackupVaultNotificationsValidationMiddleware(stack *middleware.Stack) error { 1142 return stack.Initialize.Add(&validateOpPutBackupVaultNotifications{}, middleware.After) 1143} 1144 1145func addOpStartBackupJobValidationMiddleware(stack *middleware.Stack) error { 1146 return stack.Initialize.Add(&validateOpStartBackupJob{}, middleware.After) 1147} 1148 1149func addOpStartCopyJobValidationMiddleware(stack *middleware.Stack) error { 1150 return stack.Initialize.Add(&validateOpStartCopyJob{}, middleware.After) 1151} 1152 1153func addOpStartReportJobValidationMiddleware(stack *middleware.Stack) error { 1154 return stack.Initialize.Add(&validateOpStartReportJob{}, middleware.After) 1155} 1156 1157func addOpStartRestoreJobValidationMiddleware(stack *middleware.Stack) error { 1158 return stack.Initialize.Add(&validateOpStartRestoreJob{}, middleware.After) 1159} 1160 1161func addOpStopBackupJobValidationMiddleware(stack *middleware.Stack) error { 1162 return stack.Initialize.Add(&validateOpStopBackupJob{}, middleware.After) 1163} 1164 1165func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 1166 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 1167} 1168 1169func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 1170 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 1171} 1172 1173func addOpUpdateBackupPlanValidationMiddleware(stack *middleware.Stack) error { 1174 return stack.Initialize.Add(&validateOpUpdateBackupPlan{}, middleware.After) 1175} 1176 1177func addOpUpdateFrameworkValidationMiddleware(stack *middleware.Stack) error { 1178 return stack.Initialize.Add(&validateOpUpdateFramework{}, middleware.After) 1179} 1180 1181func addOpUpdateRecoveryPointLifecycleValidationMiddleware(stack *middleware.Stack) error { 1182 return stack.Initialize.Add(&validateOpUpdateRecoveryPointLifecycle{}, middleware.After) 1183} 1184 1185func addOpUpdateReportPlanValidationMiddleware(stack *middleware.Stack) error { 1186 return stack.Initialize.Add(&validateOpUpdateReportPlan{}, middleware.After) 1187} 1188 1189func validateBackupPlanInput(v *types.BackupPlanInput) error { 1190 if v == nil { 1191 return nil 1192 } 1193 invalidParams := smithy.InvalidParamsError{Context: "BackupPlanInput"} 1194 if v.BackupPlanName == nil { 1195 invalidParams.Add(smithy.NewErrParamRequired("BackupPlanName")) 1196 } 1197 if v.Rules == nil { 1198 invalidParams.Add(smithy.NewErrParamRequired("Rules")) 1199 } else if v.Rules != nil { 1200 if err := validateBackupRulesInput(v.Rules); err != nil { 1201 invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError)) 1202 } 1203 } 1204 if invalidParams.Len() > 0 { 1205 return invalidParams 1206 } else { 1207 return nil 1208 } 1209} 1210 1211func validateBackupRuleInput(v *types.BackupRuleInput) error { 1212 if v == nil { 1213 return nil 1214 } 1215 invalidParams := smithy.InvalidParamsError{Context: "BackupRuleInput"} 1216 if v.RuleName == nil { 1217 invalidParams.Add(smithy.NewErrParamRequired("RuleName")) 1218 } 1219 if v.TargetBackupVaultName == nil { 1220 invalidParams.Add(smithy.NewErrParamRequired("TargetBackupVaultName")) 1221 } 1222 if v.CopyActions != nil { 1223 if err := validateCopyActions(v.CopyActions); err != nil { 1224 invalidParams.AddNested("CopyActions", err.(smithy.InvalidParamsError)) 1225 } 1226 } 1227 if invalidParams.Len() > 0 { 1228 return invalidParams 1229 } else { 1230 return nil 1231 } 1232} 1233 1234func validateBackupRulesInput(v []types.BackupRuleInput) error { 1235 if v == nil { 1236 return nil 1237 } 1238 invalidParams := smithy.InvalidParamsError{Context: "BackupRulesInput"} 1239 for i := range v { 1240 if err := validateBackupRuleInput(&v[i]); err != nil { 1241 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1242 } 1243 } 1244 if invalidParams.Len() > 0 { 1245 return invalidParams 1246 } else { 1247 return nil 1248 } 1249} 1250 1251func validateBackupSelection(v *types.BackupSelection) error { 1252 if v == nil { 1253 return nil 1254 } 1255 invalidParams := smithy.InvalidParamsError{Context: "BackupSelection"} 1256 if v.SelectionName == nil { 1257 invalidParams.Add(smithy.NewErrParamRequired("SelectionName")) 1258 } 1259 if v.IamRoleArn == nil { 1260 invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn")) 1261 } 1262 if v.ListOfTags != nil { 1263 if err := validateListOfTags(v.ListOfTags); err != nil { 1264 invalidParams.AddNested("ListOfTags", err.(smithy.InvalidParamsError)) 1265 } 1266 } 1267 if invalidParams.Len() > 0 { 1268 return invalidParams 1269 } else { 1270 return nil 1271 } 1272} 1273 1274func validateCondition(v *types.Condition) error { 1275 if v == nil { 1276 return nil 1277 } 1278 invalidParams := smithy.InvalidParamsError{Context: "Condition"} 1279 if len(v.ConditionType) == 0 { 1280 invalidParams.Add(smithy.NewErrParamRequired("ConditionType")) 1281 } 1282 if v.ConditionKey == nil { 1283 invalidParams.Add(smithy.NewErrParamRequired("ConditionKey")) 1284 } 1285 if v.ConditionValue == nil { 1286 invalidParams.Add(smithy.NewErrParamRequired("ConditionValue")) 1287 } 1288 if invalidParams.Len() > 0 { 1289 return invalidParams 1290 } else { 1291 return nil 1292 } 1293} 1294 1295func validateCopyAction(v *types.CopyAction) error { 1296 if v == nil { 1297 return nil 1298 } 1299 invalidParams := smithy.InvalidParamsError{Context: "CopyAction"} 1300 if v.DestinationBackupVaultArn == nil { 1301 invalidParams.Add(smithy.NewErrParamRequired("DestinationBackupVaultArn")) 1302 } 1303 if invalidParams.Len() > 0 { 1304 return invalidParams 1305 } else { 1306 return nil 1307 } 1308} 1309 1310func validateCopyActions(v []types.CopyAction) error { 1311 if v == nil { 1312 return nil 1313 } 1314 invalidParams := smithy.InvalidParamsError{Context: "CopyActions"} 1315 for i := range v { 1316 if err := validateCopyAction(&v[i]); err != nil { 1317 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1318 } 1319 } 1320 if invalidParams.Len() > 0 { 1321 return invalidParams 1322 } else { 1323 return nil 1324 } 1325} 1326 1327func validateFrameworkControl(v *types.FrameworkControl) error { 1328 if v == nil { 1329 return nil 1330 } 1331 invalidParams := smithy.InvalidParamsError{Context: "FrameworkControl"} 1332 if v.ControlName == nil { 1333 invalidParams.Add(smithy.NewErrParamRequired("ControlName")) 1334 } 1335 if invalidParams.Len() > 0 { 1336 return invalidParams 1337 } else { 1338 return nil 1339 } 1340} 1341 1342func validateFrameworkControls(v []types.FrameworkControl) error { 1343 if v == nil { 1344 return nil 1345 } 1346 invalidParams := smithy.InvalidParamsError{Context: "FrameworkControls"} 1347 for i := range v { 1348 if err := validateFrameworkControl(&v[i]); err != nil { 1349 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1350 } 1351 } 1352 if invalidParams.Len() > 0 { 1353 return invalidParams 1354 } else { 1355 return nil 1356 } 1357} 1358 1359func validateListOfTags(v []types.Condition) error { 1360 if v == nil { 1361 return nil 1362 } 1363 invalidParams := smithy.InvalidParamsError{Context: "ListOfTags"} 1364 for i := range v { 1365 if err := validateCondition(&v[i]); err != nil { 1366 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 1367 } 1368 } 1369 if invalidParams.Len() > 0 { 1370 return invalidParams 1371 } else { 1372 return nil 1373 } 1374} 1375 1376func validateReportDeliveryChannel(v *types.ReportDeliveryChannel) error { 1377 if v == nil { 1378 return nil 1379 } 1380 invalidParams := smithy.InvalidParamsError{Context: "ReportDeliveryChannel"} 1381 if v.S3BucketName == nil { 1382 invalidParams.Add(smithy.NewErrParamRequired("S3BucketName")) 1383 } 1384 if invalidParams.Len() > 0 { 1385 return invalidParams 1386 } else { 1387 return nil 1388 } 1389} 1390 1391func validateReportSetting(v *types.ReportSetting) error { 1392 if v == nil { 1393 return nil 1394 } 1395 invalidParams := smithy.InvalidParamsError{Context: "ReportSetting"} 1396 if v.ReportTemplate == nil { 1397 invalidParams.Add(smithy.NewErrParamRequired("ReportTemplate")) 1398 } 1399 if invalidParams.Len() > 0 { 1400 return invalidParams 1401 } else { 1402 return nil 1403 } 1404} 1405 1406func validateOpCreateBackupPlanInput(v *CreateBackupPlanInput) error { 1407 if v == nil { 1408 return nil 1409 } 1410 invalidParams := smithy.InvalidParamsError{Context: "CreateBackupPlanInput"} 1411 if v.BackupPlan == nil { 1412 invalidParams.Add(smithy.NewErrParamRequired("BackupPlan")) 1413 } else if v.BackupPlan != nil { 1414 if err := validateBackupPlanInput(v.BackupPlan); err != nil { 1415 invalidParams.AddNested("BackupPlan", err.(smithy.InvalidParamsError)) 1416 } 1417 } 1418 if invalidParams.Len() > 0 { 1419 return invalidParams 1420 } else { 1421 return nil 1422 } 1423} 1424 1425func validateOpCreateBackupSelectionInput(v *CreateBackupSelectionInput) error { 1426 if v == nil { 1427 return nil 1428 } 1429 invalidParams := smithy.InvalidParamsError{Context: "CreateBackupSelectionInput"} 1430 if v.BackupPlanId == nil { 1431 invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId")) 1432 } 1433 if v.BackupSelection == nil { 1434 invalidParams.Add(smithy.NewErrParamRequired("BackupSelection")) 1435 } else if v.BackupSelection != nil { 1436 if err := validateBackupSelection(v.BackupSelection); err != nil { 1437 invalidParams.AddNested("BackupSelection", err.(smithy.InvalidParamsError)) 1438 } 1439 } 1440 if invalidParams.Len() > 0 { 1441 return invalidParams 1442 } else { 1443 return nil 1444 } 1445} 1446 1447func validateOpCreateBackupVaultInput(v *CreateBackupVaultInput) error { 1448 if v == nil { 1449 return nil 1450 } 1451 invalidParams := smithy.InvalidParamsError{Context: "CreateBackupVaultInput"} 1452 if v.BackupVaultName == nil { 1453 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 1454 } 1455 if invalidParams.Len() > 0 { 1456 return invalidParams 1457 } else { 1458 return nil 1459 } 1460} 1461 1462func validateOpCreateFrameworkInput(v *CreateFrameworkInput) error { 1463 if v == nil { 1464 return nil 1465 } 1466 invalidParams := smithy.InvalidParamsError{Context: "CreateFrameworkInput"} 1467 if v.FrameworkName == nil { 1468 invalidParams.Add(smithy.NewErrParamRequired("FrameworkName")) 1469 } 1470 if v.FrameworkControls == nil { 1471 invalidParams.Add(smithy.NewErrParamRequired("FrameworkControls")) 1472 } else if v.FrameworkControls != nil { 1473 if err := validateFrameworkControls(v.FrameworkControls); err != nil { 1474 invalidParams.AddNested("FrameworkControls", err.(smithy.InvalidParamsError)) 1475 } 1476 } 1477 if invalidParams.Len() > 0 { 1478 return invalidParams 1479 } else { 1480 return nil 1481 } 1482} 1483 1484func validateOpCreateReportPlanInput(v *CreateReportPlanInput) error { 1485 if v == nil { 1486 return nil 1487 } 1488 invalidParams := smithy.InvalidParamsError{Context: "CreateReportPlanInput"} 1489 if v.ReportPlanName == nil { 1490 invalidParams.Add(smithy.NewErrParamRequired("ReportPlanName")) 1491 } 1492 if v.ReportDeliveryChannel == nil { 1493 invalidParams.Add(smithy.NewErrParamRequired("ReportDeliveryChannel")) 1494 } else if v.ReportDeliveryChannel != nil { 1495 if err := validateReportDeliveryChannel(v.ReportDeliveryChannel); err != nil { 1496 invalidParams.AddNested("ReportDeliveryChannel", err.(smithy.InvalidParamsError)) 1497 } 1498 } 1499 if v.ReportSetting == nil { 1500 invalidParams.Add(smithy.NewErrParamRequired("ReportSetting")) 1501 } else if v.ReportSetting != nil { 1502 if err := validateReportSetting(v.ReportSetting); err != nil { 1503 invalidParams.AddNested("ReportSetting", err.(smithy.InvalidParamsError)) 1504 } 1505 } 1506 if invalidParams.Len() > 0 { 1507 return invalidParams 1508 } else { 1509 return nil 1510 } 1511} 1512 1513func validateOpDeleteBackupPlanInput(v *DeleteBackupPlanInput) error { 1514 if v == nil { 1515 return nil 1516 } 1517 invalidParams := smithy.InvalidParamsError{Context: "DeleteBackupPlanInput"} 1518 if v.BackupPlanId == nil { 1519 invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId")) 1520 } 1521 if invalidParams.Len() > 0 { 1522 return invalidParams 1523 } else { 1524 return nil 1525 } 1526} 1527 1528func validateOpDeleteBackupSelectionInput(v *DeleteBackupSelectionInput) error { 1529 if v == nil { 1530 return nil 1531 } 1532 invalidParams := smithy.InvalidParamsError{Context: "DeleteBackupSelectionInput"} 1533 if v.BackupPlanId == nil { 1534 invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId")) 1535 } 1536 if v.SelectionId == nil { 1537 invalidParams.Add(smithy.NewErrParamRequired("SelectionId")) 1538 } 1539 if invalidParams.Len() > 0 { 1540 return invalidParams 1541 } else { 1542 return nil 1543 } 1544} 1545 1546func validateOpDeleteBackupVaultAccessPolicyInput(v *DeleteBackupVaultAccessPolicyInput) error { 1547 if v == nil { 1548 return nil 1549 } 1550 invalidParams := smithy.InvalidParamsError{Context: "DeleteBackupVaultAccessPolicyInput"} 1551 if v.BackupVaultName == nil { 1552 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 1553 } 1554 if invalidParams.Len() > 0 { 1555 return invalidParams 1556 } else { 1557 return nil 1558 } 1559} 1560 1561func validateOpDeleteBackupVaultInput(v *DeleteBackupVaultInput) error { 1562 if v == nil { 1563 return nil 1564 } 1565 invalidParams := smithy.InvalidParamsError{Context: "DeleteBackupVaultInput"} 1566 if v.BackupVaultName == nil { 1567 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 1568 } 1569 if invalidParams.Len() > 0 { 1570 return invalidParams 1571 } else { 1572 return nil 1573 } 1574} 1575 1576func validateOpDeleteBackupVaultNotificationsInput(v *DeleteBackupVaultNotificationsInput) error { 1577 if v == nil { 1578 return nil 1579 } 1580 invalidParams := smithy.InvalidParamsError{Context: "DeleteBackupVaultNotificationsInput"} 1581 if v.BackupVaultName == nil { 1582 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 1583 } 1584 if invalidParams.Len() > 0 { 1585 return invalidParams 1586 } else { 1587 return nil 1588 } 1589} 1590 1591func validateOpDeleteFrameworkInput(v *DeleteFrameworkInput) error { 1592 if v == nil { 1593 return nil 1594 } 1595 invalidParams := smithy.InvalidParamsError{Context: "DeleteFrameworkInput"} 1596 if v.FrameworkName == nil { 1597 invalidParams.Add(smithy.NewErrParamRequired("FrameworkName")) 1598 } 1599 if invalidParams.Len() > 0 { 1600 return invalidParams 1601 } else { 1602 return nil 1603 } 1604} 1605 1606func validateOpDeleteRecoveryPointInput(v *DeleteRecoveryPointInput) error { 1607 if v == nil { 1608 return nil 1609 } 1610 invalidParams := smithy.InvalidParamsError{Context: "DeleteRecoveryPointInput"} 1611 if v.BackupVaultName == nil { 1612 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 1613 } 1614 if v.RecoveryPointArn == nil { 1615 invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn")) 1616 } 1617 if invalidParams.Len() > 0 { 1618 return invalidParams 1619 } else { 1620 return nil 1621 } 1622} 1623 1624func validateOpDeleteReportPlanInput(v *DeleteReportPlanInput) error { 1625 if v == nil { 1626 return nil 1627 } 1628 invalidParams := smithy.InvalidParamsError{Context: "DeleteReportPlanInput"} 1629 if v.ReportPlanName == nil { 1630 invalidParams.Add(smithy.NewErrParamRequired("ReportPlanName")) 1631 } 1632 if invalidParams.Len() > 0 { 1633 return invalidParams 1634 } else { 1635 return nil 1636 } 1637} 1638 1639func validateOpDescribeBackupJobInput(v *DescribeBackupJobInput) error { 1640 if v == nil { 1641 return nil 1642 } 1643 invalidParams := smithy.InvalidParamsError{Context: "DescribeBackupJobInput"} 1644 if v.BackupJobId == nil { 1645 invalidParams.Add(smithy.NewErrParamRequired("BackupJobId")) 1646 } 1647 if invalidParams.Len() > 0 { 1648 return invalidParams 1649 } else { 1650 return nil 1651 } 1652} 1653 1654func validateOpDescribeBackupVaultInput(v *DescribeBackupVaultInput) error { 1655 if v == nil { 1656 return nil 1657 } 1658 invalidParams := smithy.InvalidParamsError{Context: "DescribeBackupVaultInput"} 1659 if v.BackupVaultName == nil { 1660 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 1661 } 1662 if invalidParams.Len() > 0 { 1663 return invalidParams 1664 } else { 1665 return nil 1666 } 1667} 1668 1669func validateOpDescribeCopyJobInput(v *DescribeCopyJobInput) error { 1670 if v == nil { 1671 return nil 1672 } 1673 invalidParams := smithy.InvalidParamsError{Context: "DescribeCopyJobInput"} 1674 if v.CopyJobId == nil { 1675 invalidParams.Add(smithy.NewErrParamRequired("CopyJobId")) 1676 } 1677 if invalidParams.Len() > 0 { 1678 return invalidParams 1679 } else { 1680 return nil 1681 } 1682} 1683 1684func validateOpDescribeFrameworkInput(v *DescribeFrameworkInput) error { 1685 if v == nil { 1686 return nil 1687 } 1688 invalidParams := smithy.InvalidParamsError{Context: "DescribeFrameworkInput"} 1689 if v.FrameworkName == nil { 1690 invalidParams.Add(smithy.NewErrParamRequired("FrameworkName")) 1691 } 1692 if invalidParams.Len() > 0 { 1693 return invalidParams 1694 } else { 1695 return nil 1696 } 1697} 1698 1699func validateOpDescribeProtectedResourceInput(v *DescribeProtectedResourceInput) error { 1700 if v == nil { 1701 return nil 1702 } 1703 invalidParams := smithy.InvalidParamsError{Context: "DescribeProtectedResourceInput"} 1704 if v.ResourceArn == nil { 1705 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1706 } 1707 if invalidParams.Len() > 0 { 1708 return invalidParams 1709 } else { 1710 return nil 1711 } 1712} 1713 1714func validateOpDescribeRecoveryPointInput(v *DescribeRecoveryPointInput) error { 1715 if v == nil { 1716 return nil 1717 } 1718 invalidParams := smithy.InvalidParamsError{Context: "DescribeRecoveryPointInput"} 1719 if v.BackupVaultName == nil { 1720 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 1721 } 1722 if v.RecoveryPointArn == nil { 1723 invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn")) 1724 } 1725 if invalidParams.Len() > 0 { 1726 return invalidParams 1727 } else { 1728 return nil 1729 } 1730} 1731 1732func validateOpDescribeReportJobInput(v *DescribeReportJobInput) error { 1733 if v == nil { 1734 return nil 1735 } 1736 invalidParams := smithy.InvalidParamsError{Context: "DescribeReportJobInput"} 1737 if v.ReportJobId == nil { 1738 invalidParams.Add(smithy.NewErrParamRequired("ReportJobId")) 1739 } 1740 if invalidParams.Len() > 0 { 1741 return invalidParams 1742 } else { 1743 return nil 1744 } 1745} 1746 1747func validateOpDescribeReportPlanInput(v *DescribeReportPlanInput) error { 1748 if v == nil { 1749 return nil 1750 } 1751 invalidParams := smithy.InvalidParamsError{Context: "DescribeReportPlanInput"} 1752 if v.ReportPlanName == nil { 1753 invalidParams.Add(smithy.NewErrParamRequired("ReportPlanName")) 1754 } 1755 if invalidParams.Len() > 0 { 1756 return invalidParams 1757 } else { 1758 return nil 1759 } 1760} 1761 1762func validateOpDescribeRestoreJobInput(v *DescribeRestoreJobInput) error { 1763 if v == nil { 1764 return nil 1765 } 1766 invalidParams := smithy.InvalidParamsError{Context: "DescribeRestoreJobInput"} 1767 if v.RestoreJobId == nil { 1768 invalidParams.Add(smithy.NewErrParamRequired("RestoreJobId")) 1769 } 1770 if invalidParams.Len() > 0 { 1771 return invalidParams 1772 } else { 1773 return nil 1774 } 1775} 1776 1777func validateOpDisassociateRecoveryPointInput(v *DisassociateRecoveryPointInput) error { 1778 if v == nil { 1779 return nil 1780 } 1781 invalidParams := smithy.InvalidParamsError{Context: "DisassociateRecoveryPointInput"} 1782 if v.BackupVaultName == nil { 1783 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 1784 } 1785 if v.RecoveryPointArn == nil { 1786 invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn")) 1787 } 1788 if invalidParams.Len() > 0 { 1789 return invalidParams 1790 } else { 1791 return nil 1792 } 1793} 1794 1795func validateOpExportBackupPlanTemplateInput(v *ExportBackupPlanTemplateInput) error { 1796 if v == nil { 1797 return nil 1798 } 1799 invalidParams := smithy.InvalidParamsError{Context: "ExportBackupPlanTemplateInput"} 1800 if v.BackupPlanId == nil { 1801 invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId")) 1802 } 1803 if invalidParams.Len() > 0 { 1804 return invalidParams 1805 } else { 1806 return nil 1807 } 1808} 1809 1810func validateOpGetBackupPlanFromJSONInput(v *GetBackupPlanFromJSONInput) error { 1811 if v == nil { 1812 return nil 1813 } 1814 invalidParams := smithy.InvalidParamsError{Context: "GetBackupPlanFromJSONInput"} 1815 if v.BackupPlanTemplateJson == nil { 1816 invalidParams.Add(smithy.NewErrParamRequired("BackupPlanTemplateJson")) 1817 } 1818 if invalidParams.Len() > 0 { 1819 return invalidParams 1820 } else { 1821 return nil 1822 } 1823} 1824 1825func validateOpGetBackupPlanFromTemplateInput(v *GetBackupPlanFromTemplateInput) error { 1826 if v == nil { 1827 return nil 1828 } 1829 invalidParams := smithy.InvalidParamsError{Context: "GetBackupPlanFromTemplateInput"} 1830 if v.BackupPlanTemplateId == nil { 1831 invalidParams.Add(smithy.NewErrParamRequired("BackupPlanTemplateId")) 1832 } 1833 if invalidParams.Len() > 0 { 1834 return invalidParams 1835 } else { 1836 return nil 1837 } 1838} 1839 1840func validateOpGetBackupPlanInput(v *GetBackupPlanInput) error { 1841 if v == nil { 1842 return nil 1843 } 1844 invalidParams := smithy.InvalidParamsError{Context: "GetBackupPlanInput"} 1845 if v.BackupPlanId == nil { 1846 invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId")) 1847 } 1848 if invalidParams.Len() > 0 { 1849 return invalidParams 1850 } else { 1851 return nil 1852 } 1853} 1854 1855func validateOpGetBackupSelectionInput(v *GetBackupSelectionInput) error { 1856 if v == nil { 1857 return nil 1858 } 1859 invalidParams := smithy.InvalidParamsError{Context: "GetBackupSelectionInput"} 1860 if v.BackupPlanId == nil { 1861 invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId")) 1862 } 1863 if v.SelectionId == nil { 1864 invalidParams.Add(smithy.NewErrParamRequired("SelectionId")) 1865 } 1866 if invalidParams.Len() > 0 { 1867 return invalidParams 1868 } else { 1869 return nil 1870 } 1871} 1872 1873func validateOpGetBackupVaultAccessPolicyInput(v *GetBackupVaultAccessPolicyInput) error { 1874 if v == nil { 1875 return nil 1876 } 1877 invalidParams := smithy.InvalidParamsError{Context: "GetBackupVaultAccessPolicyInput"} 1878 if v.BackupVaultName == nil { 1879 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 1880 } 1881 if invalidParams.Len() > 0 { 1882 return invalidParams 1883 } else { 1884 return nil 1885 } 1886} 1887 1888func validateOpGetBackupVaultNotificationsInput(v *GetBackupVaultNotificationsInput) error { 1889 if v == nil { 1890 return nil 1891 } 1892 invalidParams := smithy.InvalidParamsError{Context: "GetBackupVaultNotificationsInput"} 1893 if v.BackupVaultName == nil { 1894 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 1895 } 1896 if invalidParams.Len() > 0 { 1897 return invalidParams 1898 } else { 1899 return nil 1900 } 1901} 1902 1903func validateOpGetRecoveryPointRestoreMetadataInput(v *GetRecoveryPointRestoreMetadataInput) error { 1904 if v == nil { 1905 return nil 1906 } 1907 invalidParams := smithy.InvalidParamsError{Context: "GetRecoveryPointRestoreMetadataInput"} 1908 if v.BackupVaultName == nil { 1909 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 1910 } 1911 if v.RecoveryPointArn == nil { 1912 invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn")) 1913 } 1914 if invalidParams.Len() > 0 { 1915 return invalidParams 1916 } else { 1917 return nil 1918 } 1919} 1920 1921func validateOpListBackupPlanVersionsInput(v *ListBackupPlanVersionsInput) error { 1922 if v == nil { 1923 return nil 1924 } 1925 invalidParams := smithy.InvalidParamsError{Context: "ListBackupPlanVersionsInput"} 1926 if v.BackupPlanId == nil { 1927 invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId")) 1928 } 1929 if invalidParams.Len() > 0 { 1930 return invalidParams 1931 } else { 1932 return nil 1933 } 1934} 1935 1936func validateOpListBackupSelectionsInput(v *ListBackupSelectionsInput) error { 1937 if v == nil { 1938 return nil 1939 } 1940 invalidParams := smithy.InvalidParamsError{Context: "ListBackupSelectionsInput"} 1941 if v.BackupPlanId == nil { 1942 invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId")) 1943 } 1944 if invalidParams.Len() > 0 { 1945 return invalidParams 1946 } else { 1947 return nil 1948 } 1949} 1950 1951func validateOpListRecoveryPointsByBackupVaultInput(v *ListRecoveryPointsByBackupVaultInput) error { 1952 if v == nil { 1953 return nil 1954 } 1955 invalidParams := smithy.InvalidParamsError{Context: "ListRecoveryPointsByBackupVaultInput"} 1956 if v.BackupVaultName == nil { 1957 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 1958 } 1959 if invalidParams.Len() > 0 { 1960 return invalidParams 1961 } else { 1962 return nil 1963 } 1964} 1965 1966func validateOpListRecoveryPointsByResourceInput(v *ListRecoveryPointsByResourceInput) error { 1967 if v == nil { 1968 return nil 1969 } 1970 invalidParams := smithy.InvalidParamsError{Context: "ListRecoveryPointsByResourceInput"} 1971 if v.ResourceArn == nil { 1972 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1973 } 1974 if invalidParams.Len() > 0 { 1975 return invalidParams 1976 } else { 1977 return nil 1978 } 1979} 1980 1981func validateOpListTagsInput(v *ListTagsInput) error { 1982 if v == nil { 1983 return nil 1984 } 1985 invalidParams := smithy.InvalidParamsError{Context: "ListTagsInput"} 1986 if v.ResourceArn == nil { 1987 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 1988 } 1989 if invalidParams.Len() > 0 { 1990 return invalidParams 1991 } else { 1992 return nil 1993 } 1994} 1995 1996func validateOpPutBackupVaultAccessPolicyInput(v *PutBackupVaultAccessPolicyInput) error { 1997 if v == nil { 1998 return nil 1999 } 2000 invalidParams := smithy.InvalidParamsError{Context: "PutBackupVaultAccessPolicyInput"} 2001 if v.BackupVaultName == nil { 2002 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 2003 } 2004 if invalidParams.Len() > 0 { 2005 return invalidParams 2006 } else { 2007 return nil 2008 } 2009} 2010 2011func validateOpPutBackupVaultNotificationsInput(v *PutBackupVaultNotificationsInput) error { 2012 if v == nil { 2013 return nil 2014 } 2015 invalidParams := smithy.InvalidParamsError{Context: "PutBackupVaultNotificationsInput"} 2016 if v.BackupVaultName == nil { 2017 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 2018 } 2019 if v.SNSTopicArn == nil { 2020 invalidParams.Add(smithy.NewErrParamRequired("SNSTopicArn")) 2021 } 2022 if v.BackupVaultEvents == nil { 2023 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultEvents")) 2024 } 2025 if invalidParams.Len() > 0 { 2026 return invalidParams 2027 } else { 2028 return nil 2029 } 2030} 2031 2032func validateOpStartBackupJobInput(v *StartBackupJobInput) error { 2033 if v == nil { 2034 return nil 2035 } 2036 invalidParams := smithy.InvalidParamsError{Context: "StartBackupJobInput"} 2037 if v.BackupVaultName == nil { 2038 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 2039 } 2040 if v.ResourceArn == nil { 2041 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2042 } 2043 if v.IamRoleArn == nil { 2044 invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn")) 2045 } 2046 if invalidParams.Len() > 0 { 2047 return invalidParams 2048 } else { 2049 return nil 2050 } 2051} 2052 2053func validateOpStartCopyJobInput(v *StartCopyJobInput) error { 2054 if v == nil { 2055 return nil 2056 } 2057 invalidParams := smithy.InvalidParamsError{Context: "StartCopyJobInput"} 2058 if v.RecoveryPointArn == nil { 2059 invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn")) 2060 } 2061 if v.SourceBackupVaultName == nil { 2062 invalidParams.Add(smithy.NewErrParamRequired("SourceBackupVaultName")) 2063 } 2064 if v.DestinationBackupVaultArn == nil { 2065 invalidParams.Add(smithy.NewErrParamRequired("DestinationBackupVaultArn")) 2066 } 2067 if v.IamRoleArn == nil { 2068 invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn")) 2069 } 2070 if invalidParams.Len() > 0 { 2071 return invalidParams 2072 } else { 2073 return nil 2074 } 2075} 2076 2077func validateOpStartReportJobInput(v *StartReportJobInput) error { 2078 if v == nil { 2079 return nil 2080 } 2081 invalidParams := smithy.InvalidParamsError{Context: "StartReportJobInput"} 2082 if v.ReportPlanName == nil { 2083 invalidParams.Add(smithy.NewErrParamRequired("ReportPlanName")) 2084 } 2085 if invalidParams.Len() > 0 { 2086 return invalidParams 2087 } else { 2088 return nil 2089 } 2090} 2091 2092func validateOpStartRestoreJobInput(v *StartRestoreJobInput) error { 2093 if v == nil { 2094 return nil 2095 } 2096 invalidParams := smithy.InvalidParamsError{Context: "StartRestoreJobInput"} 2097 if v.RecoveryPointArn == nil { 2098 invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn")) 2099 } 2100 if v.Metadata == nil { 2101 invalidParams.Add(smithy.NewErrParamRequired("Metadata")) 2102 } 2103 if v.IamRoleArn == nil { 2104 invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn")) 2105 } 2106 if invalidParams.Len() > 0 { 2107 return invalidParams 2108 } else { 2109 return nil 2110 } 2111} 2112 2113func validateOpStopBackupJobInput(v *StopBackupJobInput) error { 2114 if v == nil { 2115 return nil 2116 } 2117 invalidParams := smithy.InvalidParamsError{Context: "StopBackupJobInput"} 2118 if v.BackupJobId == nil { 2119 invalidParams.Add(smithy.NewErrParamRequired("BackupJobId")) 2120 } 2121 if invalidParams.Len() > 0 { 2122 return invalidParams 2123 } else { 2124 return nil 2125 } 2126} 2127 2128func validateOpTagResourceInput(v *TagResourceInput) error { 2129 if v == nil { 2130 return nil 2131 } 2132 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 2133 if v.ResourceArn == nil { 2134 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2135 } 2136 if v.Tags == nil { 2137 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 2138 } 2139 if invalidParams.Len() > 0 { 2140 return invalidParams 2141 } else { 2142 return nil 2143 } 2144} 2145 2146func validateOpUntagResourceInput(v *UntagResourceInput) error { 2147 if v == nil { 2148 return nil 2149 } 2150 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 2151 if v.ResourceArn == nil { 2152 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 2153 } 2154 if v.TagKeyList == nil { 2155 invalidParams.Add(smithy.NewErrParamRequired("TagKeyList")) 2156 } 2157 if invalidParams.Len() > 0 { 2158 return invalidParams 2159 } else { 2160 return nil 2161 } 2162} 2163 2164func validateOpUpdateBackupPlanInput(v *UpdateBackupPlanInput) error { 2165 if v == nil { 2166 return nil 2167 } 2168 invalidParams := smithy.InvalidParamsError{Context: "UpdateBackupPlanInput"} 2169 if v.BackupPlanId == nil { 2170 invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId")) 2171 } 2172 if v.BackupPlan == nil { 2173 invalidParams.Add(smithy.NewErrParamRequired("BackupPlan")) 2174 } else if v.BackupPlan != nil { 2175 if err := validateBackupPlanInput(v.BackupPlan); err != nil { 2176 invalidParams.AddNested("BackupPlan", err.(smithy.InvalidParamsError)) 2177 } 2178 } 2179 if invalidParams.Len() > 0 { 2180 return invalidParams 2181 } else { 2182 return nil 2183 } 2184} 2185 2186func validateOpUpdateFrameworkInput(v *UpdateFrameworkInput) error { 2187 if v == nil { 2188 return nil 2189 } 2190 invalidParams := smithy.InvalidParamsError{Context: "UpdateFrameworkInput"} 2191 if v.FrameworkName == nil { 2192 invalidParams.Add(smithy.NewErrParamRequired("FrameworkName")) 2193 } 2194 if v.FrameworkControls != nil { 2195 if err := validateFrameworkControls(v.FrameworkControls); err != nil { 2196 invalidParams.AddNested("FrameworkControls", err.(smithy.InvalidParamsError)) 2197 } 2198 } 2199 if invalidParams.Len() > 0 { 2200 return invalidParams 2201 } else { 2202 return nil 2203 } 2204} 2205 2206func validateOpUpdateRecoveryPointLifecycleInput(v *UpdateRecoveryPointLifecycleInput) error { 2207 if v == nil { 2208 return nil 2209 } 2210 invalidParams := smithy.InvalidParamsError{Context: "UpdateRecoveryPointLifecycleInput"} 2211 if v.BackupVaultName == nil { 2212 invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName")) 2213 } 2214 if v.RecoveryPointArn == nil { 2215 invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn")) 2216 } 2217 if invalidParams.Len() > 0 { 2218 return invalidParams 2219 } else { 2220 return nil 2221 } 2222} 2223 2224func validateOpUpdateReportPlanInput(v *UpdateReportPlanInput) error { 2225 if v == nil { 2226 return nil 2227 } 2228 invalidParams := smithy.InvalidParamsError{Context: "UpdateReportPlanInput"} 2229 if v.ReportPlanName == nil { 2230 invalidParams.Add(smithy.NewErrParamRequired("ReportPlanName")) 2231 } 2232 if v.ReportDeliveryChannel != nil { 2233 if err := validateReportDeliveryChannel(v.ReportDeliveryChannel); err != nil { 2234 invalidParams.AddNested("ReportDeliveryChannel", err.(smithy.InvalidParamsError)) 2235 } 2236 } 2237 if v.ReportSetting != nil { 2238 if err := validateReportSetting(v.ReportSetting); err != nil { 2239 invalidParams.AddNested("ReportSetting", err.(smithy.InvalidParamsError)) 2240 } 2241 } 2242 if invalidParams.Len() > 0 { 2243 return invalidParams 2244 } else { 2245 return nil 2246 } 2247} 2248