1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package glacier 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/glacier/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpAbortMultipartUpload struct { 14} 15 16func (*validateOpAbortMultipartUpload) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpAbortMultipartUpload) 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.(*AbortMultipartUploadInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpAbortMultipartUploadInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpAbortVaultLock struct { 34} 35 36func (*validateOpAbortVaultLock) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpAbortVaultLock) 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.(*AbortVaultLockInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpAbortVaultLockInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpAddTagsToVault struct { 54} 55 56func (*validateOpAddTagsToVault) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpAddTagsToVault) 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.(*AddTagsToVaultInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpAddTagsToVaultInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpCompleteMultipartUpload struct { 74} 75 76func (*validateOpCompleteMultipartUpload) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpCompleteMultipartUpload) 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.(*CompleteMultipartUploadInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpCompleteMultipartUploadInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpCompleteVaultLock struct { 94} 95 96func (*validateOpCompleteVaultLock) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpCompleteVaultLock) 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.(*CompleteVaultLockInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpCompleteVaultLockInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpCreateVault struct { 114} 115 116func (*validateOpCreateVault) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpCreateVault) 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.(*CreateVaultInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpCreateVaultInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpDeleteArchive struct { 134} 135 136func (*validateOpDeleteArchive) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpDeleteArchive) 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.(*DeleteArchiveInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpDeleteArchiveInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpDeleteVaultAccessPolicy struct { 154} 155 156func (*validateOpDeleteVaultAccessPolicy) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpDeleteVaultAccessPolicy) 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.(*DeleteVaultAccessPolicyInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpDeleteVaultAccessPolicyInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpDeleteVault struct { 174} 175 176func (*validateOpDeleteVault) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpDeleteVault) 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.(*DeleteVaultInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpDeleteVaultInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpDeleteVaultNotifications struct { 194} 195 196func (*validateOpDeleteVaultNotifications) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpDeleteVaultNotifications) 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.(*DeleteVaultNotificationsInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpDeleteVaultNotificationsInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpDescribeJob struct { 214} 215 216func (*validateOpDescribeJob) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpDescribeJob) 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.(*DescribeJobInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpDescribeJobInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpDescribeVault struct { 234} 235 236func (*validateOpDescribeVault) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpDescribeVault) 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.(*DescribeVaultInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpDescribeVaultInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpGetDataRetrievalPolicy struct { 254} 255 256func (*validateOpGetDataRetrievalPolicy) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpGetDataRetrievalPolicy) 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.(*GetDataRetrievalPolicyInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpGetDataRetrievalPolicyInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpGetJobOutput struct { 274} 275 276func (*validateOpGetJobOutput) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpGetJobOutput) 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.(*GetJobOutputInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpGetJobOutputInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpGetVaultAccessPolicy struct { 294} 295 296func (*validateOpGetVaultAccessPolicy) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpGetVaultAccessPolicy) 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.(*GetVaultAccessPolicyInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpGetVaultAccessPolicyInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpGetVaultLock struct { 314} 315 316func (*validateOpGetVaultLock) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpGetVaultLock) 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.(*GetVaultLockInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpGetVaultLockInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpGetVaultNotifications struct { 334} 335 336func (*validateOpGetVaultNotifications) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpGetVaultNotifications) 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.(*GetVaultNotificationsInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpGetVaultNotificationsInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpInitiateJob struct { 354} 355 356func (*validateOpInitiateJob) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpInitiateJob) 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.(*InitiateJobInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpInitiateJobInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpInitiateMultipartUpload struct { 374} 375 376func (*validateOpInitiateMultipartUpload) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpInitiateMultipartUpload) 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.(*InitiateMultipartUploadInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpInitiateMultipartUploadInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpInitiateVaultLock struct { 394} 395 396func (*validateOpInitiateVaultLock) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpInitiateVaultLock) 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.(*InitiateVaultLockInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpInitiateVaultLockInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpListJobs struct { 414} 415 416func (*validateOpListJobs) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpListJobs) 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.(*ListJobsInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpListJobsInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpListMultipartUploads struct { 434} 435 436func (*validateOpListMultipartUploads) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpListMultipartUploads) 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.(*ListMultipartUploadsInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpListMultipartUploadsInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpListParts struct { 454} 455 456func (*validateOpListParts) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpListParts) 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.(*ListPartsInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpListPartsInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpListProvisionedCapacity struct { 474} 475 476func (*validateOpListProvisionedCapacity) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpListProvisionedCapacity) 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.(*ListProvisionedCapacityInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpListProvisionedCapacityInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpListTagsForVault struct { 494} 495 496func (*validateOpListTagsForVault) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpListTagsForVault) 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.(*ListTagsForVaultInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpListTagsForVaultInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpListVaults struct { 514} 515 516func (*validateOpListVaults) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpListVaults) 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.(*ListVaultsInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpListVaultsInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpPurchaseProvisionedCapacity struct { 534} 535 536func (*validateOpPurchaseProvisionedCapacity) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpPurchaseProvisionedCapacity) 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.(*PurchaseProvisionedCapacityInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpPurchaseProvisionedCapacityInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpRemoveTagsFromVault struct { 554} 555 556func (*validateOpRemoveTagsFromVault) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpRemoveTagsFromVault) 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.(*RemoveTagsFromVaultInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpRemoveTagsFromVaultInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpSetDataRetrievalPolicy struct { 574} 575 576func (*validateOpSetDataRetrievalPolicy) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpSetDataRetrievalPolicy) 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.(*SetDataRetrievalPolicyInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpSetDataRetrievalPolicyInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpSetVaultAccessPolicy struct { 594} 595 596func (*validateOpSetVaultAccessPolicy) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpSetVaultAccessPolicy) 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.(*SetVaultAccessPolicyInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpSetVaultAccessPolicyInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpSetVaultNotifications struct { 614} 615 616func (*validateOpSetVaultNotifications) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpSetVaultNotifications) 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.(*SetVaultNotificationsInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpSetVaultNotificationsInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpUploadArchive struct { 634} 635 636func (*validateOpUploadArchive) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpUploadArchive) 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.(*UploadArchiveInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpUploadArchiveInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpUploadMultipartPart struct { 654} 655 656func (*validateOpUploadMultipartPart) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpUploadMultipartPart) 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.(*UploadMultipartPartInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpUploadMultipartPartInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673func addOpAbortMultipartUploadValidationMiddleware(stack *middleware.Stack) error { 674 return stack.Initialize.Add(&validateOpAbortMultipartUpload{}, middleware.After) 675} 676 677func addOpAbortVaultLockValidationMiddleware(stack *middleware.Stack) error { 678 return stack.Initialize.Add(&validateOpAbortVaultLock{}, middleware.After) 679} 680 681func addOpAddTagsToVaultValidationMiddleware(stack *middleware.Stack) error { 682 return stack.Initialize.Add(&validateOpAddTagsToVault{}, middleware.After) 683} 684 685func addOpCompleteMultipartUploadValidationMiddleware(stack *middleware.Stack) error { 686 return stack.Initialize.Add(&validateOpCompleteMultipartUpload{}, middleware.After) 687} 688 689func addOpCompleteVaultLockValidationMiddleware(stack *middleware.Stack) error { 690 return stack.Initialize.Add(&validateOpCompleteVaultLock{}, middleware.After) 691} 692 693func addOpCreateVaultValidationMiddleware(stack *middleware.Stack) error { 694 return stack.Initialize.Add(&validateOpCreateVault{}, middleware.After) 695} 696 697func addOpDeleteArchiveValidationMiddleware(stack *middleware.Stack) error { 698 return stack.Initialize.Add(&validateOpDeleteArchive{}, middleware.After) 699} 700 701func addOpDeleteVaultAccessPolicyValidationMiddleware(stack *middleware.Stack) error { 702 return stack.Initialize.Add(&validateOpDeleteVaultAccessPolicy{}, middleware.After) 703} 704 705func addOpDeleteVaultValidationMiddleware(stack *middleware.Stack) error { 706 return stack.Initialize.Add(&validateOpDeleteVault{}, middleware.After) 707} 708 709func addOpDeleteVaultNotificationsValidationMiddleware(stack *middleware.Stack) error { 710 return stack.Initialize.Add(&validateOpDeleteVaultNotifications{}, middleware.After) 711} 712 713func addOpDescribeJobValidationMiddleware(stack *middleware.Stack) error { 714 return stack.Initialize.Add(&validateOpDescribeJob{}, middleware.After) 715} 716 717func addOpDescribeVaultValidationMiddleware(stack *middleware.Stack) error { 718 return stack.Initialize.Add(&validateOpDescribeVault{}, middleware.After) 719} 720 721func addOpGetDataRetrievalPolicyValidationMiddleware(stack *middleware.Stack) error { 722 return stack.Initialize.Add(&validateOpGetDataRetrievalPolicy{}, middleware.After) 723} 724 725func addOpGetJobOutputValidationMiddleware(stack *middleware.Stack) error { 726 return stack.Initialize.Add(&validateOpGetJobOutput{}, middleware.After) 727} 728 729func addOpGetVaultAccessPolicyValidationMiddleware(stack *middleware.Stack) error { 730 return stack.Initialize.Add(&validateOpGetVaultAccessPolicy{}, middleware.After) 731} 732 733func addOpGetVaultLockValidationMiddleware(stack *middleware.Stack) error { 734 return stack.Initialize.Add(&validateOpGetVaultLock{}, middleware.After) 735} 736 737func addOpGetVaultNotificationsValidationMiddleware(stack *middleware.Stack) error { 738 return stack.Initialize.Add(&validateOpGetVaultNotifications{}, middleware.After) 739} 740 741func addOpInitiateJobValidationMiddleware(stack *middleware.Stack) error { 742 return stack.Initialize.Add(&validateOpInitiateJob{}, middleware.After) 743} 744 745func addOpInitiateMultipartUploadValidationMiddleware(stack *middleware.Stack) error { 746 return stack.Initialize.Add(&validateOpInitiateMultipartUpload{}, middleware.After) 747} 748 749func addOpInitiateVaultLockValidationMiddleware(stack *middleware.Stack) error { 750 return stack.Initialize.Add(&validateOpInitiateVaultLock{}, middleware.After) 751} 752 753func addOpListJobsValidationMiddleware(stack *middleware.Stack) error { 754 return stack.Initialize.Add(&validateOpListJobs{}, middleware.After) 755} 756 757func addOpListMultipartUploadsValidationMiddleware(stack *middleware.Stack) error { 758 return stack.Initialize.Add(&validateOpListMultipartUploads{}, middleware.After) 759} 760 761func addOpListPartsValidationMiddleware(stack *middleware.Stack) error { 762 return stack.Initialize.Add(&validateOpListParts{}, middleware.After) 763} 764 765func addOpListProvisionedCapacityValidationMiddleware(stack *middleware.Stack) error { 766 return stack.Initialize.Add(&validateOpListProvisionedCapacity{}, middleware.After) 767} 768 769func addOpListTagsForVaultValidationMiddleware(stack *middleware.Stack) error { 770 return stack.Initialize.Add(&validateOpListTagsForVault{}, middleware.After) 771} 772 773func addOpListVaultsValidationMiddleware(stack *middleware.Stack) error { 774 return stack.Initialize.Add(&validateOpListVaults{}, middleware.After) 775} 776 777func addOpPurchaseProvisionedCapacityValidationMiddleware(stack *middleware.Stack) error { 778 return stack.Initialize.Add(&validateOpPurchaseProvisionedCapacity{}, middleware.After) 779} 780 781func addOpRemoveTagsFromVaultValidationMiddleware(stack *middleware.Stack) error { 782 return stack.Initialize.Add(&validateOpRemoveTagsFromVault{}, middleware.After) 783} 784 785func addOpSetDataRetrievalPolicyValidationMiddleware(stack *middleware.Stack) error { 786 return stack.Initialize.Add(&validateOpSetDataRetrievalPolicy{}, middleware.After) 787} 788 789func addOpSetVaultAccessPolicyValidationMiddleware(stack *middleware.Stack) error { 790 return stack.Initialize.Add(&validateOpSetVaultAccessPolicy{}, middleware.After) 791} 792 793func addOpSetVaultNotificationsValidationMiddleware(stack *middleware.Stack) error { 794 return stack.Initialize.Add(&validateOpSetVaultNotifications{}, middleware.After) 795} 796 797func addOpUploadArchiveValidationMiddleware(stack *middleware.Stack) error { 798 return stack.Initialize.Add(&validateOpUploadArchive{}, middleware.After) 799} 800 801func addOpUploadMultipartPartValidationMiddleware(stack *middleware.Stack) error { 802 return stack.Initialize.Add(&validateOpUploadMultipartPart{}, middleware.After) 803} 804 805func validateAccessControlPolicyList(v []types.Grant) error { 806 if v == nil { 807 return nil 808 } 809 invalidParams := smithy.InvalidParamsError{Context: "AccessControlPolicyList"} 810 for i := range v { 811 if err := validateGrant(&v[i]); err != nil { 812 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 813 } 814 } 815 if invalidParams.Len() > 0 { 816 return invalidParams 817 } else { 818 return nil 819 } 820} 821 822func validateGrant(v *types.Grant) error { 823 if v == nil { 824 return nil 825 } 826 invalidParams := smithy.InvalidParamsError{Context: "Grant"} 827 if v.Grantee != nil { 828 if err := validateGrantee(v.Grantee); err != nil { 829 invalidParams.AddNested("Grantee", err.(smithy.InvalidParamsError)) 830 } 831 } 832 if invalidParams.Len() > 0 { 833 return invalidParams 834 } else { 835 return nil 836 } 837} 838 839func validateGrantee(v *types.Grantee) error { 840 if v == nil { 841 return nil 842 } 843 invalidParams := smithy.InvalidParamsError{Context: "Grantee"} 844 if len(v.Type) == 0 { 845 invalidParams.Add(smithy.NewErrParamRequired("Type")) 846 } 847 if invalidParams.Len() > 0 { 848 return invalidParams 849 } else { 850 return nil 851 } 852} 853 854func validateJobParameters(v *types.JobParameters) error { 855 if v == nil { 856 return nil 857 } 858 invalidParams := smithy.InvalidParamsError{Context: "JobParameters"} 859 if v.OutputLocation != nil { 860 if err := validateOutputLocation(v.OutputLocation); err != nil { 861 invalidParams.AddNested("OutputLocation", err.(smithy.InvalidParamsError)) 862 } 863 } 864 if invalidParams.Len() > 0 { 865 return invalidParams 866 } else { 867 return nil 868 } 869} 870 871func validateOutputLocation(v *types.OutputLocation) error { 872 if v == nil { 873 return nil 874 } 875 invalidParams := smithy.InvalidParamsError{Context: "OutputLocation"} 876 if v.S3 != nil { 877 if err := validateS3Location(v.S3); err != nil { 878 invalidParams.AddNested("S3", err.(smithy.InvalidParamsError)) 879 } 880 } 881 if invalidParams.Len() > 0 { 882 return invalidParams 883 } else { 884 return nil 885 } 886} 887 888func validateS3Location(v *types.S3Location) error { 889 if v == nil { 890 return nil 891 } 892 invalidParams := smithy.InvalidParamsError{Context: "S3Location"} 893 if v.AccessControlList != nil { 894 if err := validateAccessControlPolicyList(v.AccessControlList); err != nil { 895 invalidParams.AddNested("AccessControlList", err.(smithy.InvalidParamsError)) 896 } 897 } 898 if invalidParams.Len() > 0 { 899 return invalidParams 900 } else { 901 return nil 902 } 903} 904 905func validateOpAbortMultipartUploadInput(v *AbortMultipartUploadInput) error { 906 if v == nil { 907 return nil 908 } 909 invalidParams := smithy.InvalidParamsError{Context: "AbortMultipartUploadInput"} 910 if v.AccountId == nil { 911 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 912 } 913 if v.VaultName == nil { 914 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 915 } 916 if v.UploadId == nil { 917 invalidParams.Add(smithy.NewErrParamRequired("UploadId")) 918 } 919 if invalidParams.Len() > 0 { 920 return invalidParams 921 } else { 922 return nil 923 } 924} 925 926func validateOpAbortVaultLockInput(v *AbortVaultLockInput) error { 927 if v == nil { 928 return nil 929 } 930 invalidParams := smithy.InvalidParamsError{Context: "AbortVaultLockInput"} 931 if v.AccountId == nil { 932 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 933 } 934 if v.VaultName == nil { 935 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 936 } 937 if invalidParams.Len() > 0 { 938 return invalidParams 939 } else { 940 return nil 941 } 942} 943 944func validateOpAddTagsToVaultInput(v *AddTagsToVaultInput) error { 945 if v == nil { 946 return nil 947 } 948 invalidParams := smithy.InvalidParamsError{Context: "AddTagsToVaultInput"} 949 if v.AccountId == nil { 950 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 951 } 952 if v.VaultName == nil { 953 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 954 } 955 if invalidParams.Len() > 0 { 956 return invalidParams 957 } else { 958 return nil 959 } 960} 961 962func validateOpCompleteMultipartUploadInput(v *CompleteMultipartUploadInput) error { 963 if v == nil { 964 return nil 965 } 966 invalidParams := smithy.InvalidParamsError{Context: "CompleteMultipartUploadInput"} 967 if v.AccountId == nil { 968 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 969 } 970 if v.VaultName == nil { 971 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 972 } 973 if v.UploadId == nil { 974 invalidParams.Add(smithy.NewErrParamRequired("UploadId")) 975 } 976 if invalidParams.Len() > 0 { 977 return invalidParams 978 } else { 979 return nil 980 } 981} 982 983func validateOpCompleteVaultLockInput(v *CompleteVaultLockInput) error { 984 if v == nil { 985 return nil 986 } 987 invalidParams := smithy.InvalidParamsError{Context: "CompleteVaultLockInput"} 988 if v.AccountId == nil { 989 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 990 } 991 if v.VaultName == nil { 992 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 993 } 994 if v.LockId == nil { 995 invalidParams.Add(smithy.NewErrParamRequired("LockId")) 996 } 997 if invalidParams.Len() > 0 { 998 return invalidParams 999 } else { 1000 return nil 1001 } 1002} 1003 1004func validateOpCreateVaultInput(v *CreateVaultInput) error { 1005 if v == nil { 1006 return nil 1007 } 1008 invalidParams := smithy.InvalidParamsError{Context: "CreateVaultInput"} 1009 if v.AccountId == nil { 1010 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1011 } 1012 if v.VaultName == nil { 1013 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1014 } 1015 if invalidParams.Len() > 0 { 1016 return invalidParams 1017 } else { 1018 return nil 1019 } 1020} 1021 1022func validateOpDeleteArchiveInput(v *DeleteArchiveInput) error { 1023 if v == nil { 1024 return nil 1025 } 1026 invalidParams := smithy.InvalidParamsError{Context: "DeleteArchiveInput"} 1027 if v.AccountId == nil { 1028 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1029 } 1030 if v.VaultName == nil { 1031 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1032 } 1033 if v.ArchiveId == nil { 1034 invalidParams.Add(smithy.NewErrParamRequired("ArchiveId")) 1035 } 1036 if invalidParams.Len() > 0 { 1037 return invalidParams 1038 } else { 1039 return nil 1040 } 1041} 1042 1043func validateOpDeleteVaultAccessPolicyInput(v *DeleteVaultAccessPolicyInput) error { 1044 if v == nil { 1045 return nil 1046 } 1047 invalidParams := smithy.InvalidParamsError{Context: "DeleteVaultAccessPolicyInput"} 1048 if v.AccountId == nil { 1049 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1050 } 1051 if v.VaultName == nil { 1052 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1053 } 1054 if invalidParams.Len() > 0 { 1055 return invalidParams 1056 } else { 1057 return nil 1058 } 1059} 1060 1061func validateOpDeleteVaultInput(v *DeleteVaultInput) error { 1062 if v == nil { 1063 return nil 1064 } 1065 invalidParams := smithy.InvalidParamsError{Context: "DeleteVaultInput"} 1066 if v.AccountId == nil { 1067 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1068 } 1069 if v.VaultName == nil { 1070 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1071 } 1072 if invalidParams.Len() > 0 { 1073 return invalidParams 1074 } else { 1075 return nil 1076 } 1077} 1078 1079func validateOpDeleteVaultNotificationsInput(v *DeleteVaultNotificationsInput) error { 1080 if v == nil { 1081 return nil 1082 } 1083 invalidParams := smithy.InvalidParamsError{Context: "DeleteVaultNotificationsInput"} 1084 if v.AccountId == nil { 1085 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1086 } 1087 if v.VaultName == nil { 1088 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1089 } 1090 if invalidParams.Len() > 0 { 1091 return invalidParams 1092 } else { 1093 return nil 1094 } 1095} 1096 1097func validateOpDescribeJobInput(v *DescribeJobInput) error { 1098 if v == nil { 1099 return nil 1100 } 1101 invalidParams := smithy.InvalidParamsError{Context: "DescribeJobInput"} 1102 if v.AccountId == nil { 1103 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1104 } 1105 if v.VaultName == nil { 1106 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1107 } 1108 if v.JobId == nil { 1109 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 1110 } 1111 if invalidParams.Len() > 0 { 1112 return invalidParams 1113 } else { 1114 return nil 1115 } 1116} 1117 1118func validateOpDescribeVaultInput(v *DescribeVaultInput) error { 1119 if v == nil { 1120 return nil 1121 } 1122 invalidParams := smithy.InvalidParamsError{Context: "DescribeVaultInput"} 1123 if v.AccountId == nil { 1124 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1125 } 1126 if v.VaultName == nil { 1127 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1128 } 1129 if invalidParams.Len() > 0 { 1130 return invalidParams 1131 } else { 1132 return nil 1133 } 1134} 1135 1136func validateOpGetDataRetrievalPolicyInput(v *GetDataRetrievalPolicyInput) error { 1137 if v == nil { 1138 return nil 1139 } 1140 invalidParams := smithy.InvalidParamsError{Context: "GetDataRetrievalPolicyInput"} 1141 if v.AccountId == nil { 1142 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1143 } 1144 if invalidParams.Len() > 0 { 1145 return invalidParams 1146 } else { 1147 return nil 1148 } 1149} 1150 1151func validateOpGetJobOutputInput(v *GetJobOutputInput) error { 1152 if v == nil { 1153 return nil 1154 } 1155 invalidParams := smithy.InvalidParamsError{Context: "GetJobOutputInput"} 1156 if v.AccountId == nil { 1157 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1158 } 1159 if v.VaultName == nil { 1160 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1161 } 1162 if v.JobId == nil { 1163 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 1164 } 1165 if invalidParams.Len() > 0 { 1166 return invalidParams 1167 } else { 1168 return nil 1169 } 1170} 1171 1172func validateOpGetVaultAccessPolicyInput(v *GetVaultAccessPolicyInput) error { 1173 if v == nil { 1174 return nil 1175 } 1176 invalidParams := smithy.InvalidParamsError{Context: "GetVaultAccessPolicyInput"} 1177 if v.AccountId == nil { 1178 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1179 } 1180 if v.VaultName == nil { 1181 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1182 } 1183 if invalidParams.Len() > 0 { 1184 return invalidParams 1185 } else { 1186 return nil 1187 } 1188} 1189 1190func validateOpGetVaultLockInput(v *GetVaultLockInput) error { 1191 if v == nil { 1192 return nil 1193 } 1194 invalidParams := smithy.InvalidParamsError{Context: "GetVaultLockInput"} 1195 if v.AccountId == nil { 1196 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1197 } 1198 if v.VaultName == nil { 1199 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1200 } 1201 if invalidParams.Len() > 0 { 1202 return invalidParams 1203 } else { 1204 return nil 1205 } 1206} 1207 1208func validateOpGetVaultNotificationsInput(v *GetVaultNotificationsInput) error { 1209 if v == nil { 1210 return nil 1211 } 1212 invalidParams := smithy.InvalidParamsError{Context: "GetVaultNotificationsInput"} 1213 if v.AccountId == nil { 1214 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1215 } 1216 if v.VaultName == nil { 1217 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1218 } 1219 if invalidParams.Len() > 0 { 1220 return invalidParams 1221 } else { 1222 return nil 1223 } 1224} 1225 1226func validateOpInitiateJobInput(v *InitiateJobInput) error { 1227 if v == nil { 1228 return nil 1229 } 1230 invalidParams := smithy.InvalidParamsError{Context: "InitiateJobInput"} 1231 if v.AccountId == nil { 1232 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1233 } 1234 if v.VaultName == nil { 1235 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1236 } 1237 if v.JobParameters != nil { 1238 if err := validateJobParameters(v.JobParameters); err != nil { 1239 invalidParams.AddNested("JobParameters", err.(smithy.InvalidParamsError)) 1240 } 1241 } 1242 if invalidParams.Len() > 0 { 1243 return invalidParams 1244 } else { 1245 return nil 1246 } 1247} 1248 1249func validateOpInitiateMultipartUploadInput(v *InitiateMultipartUploadInput) error { 1250 if v == nil { 1251 return nil 1252 } 1253 invalidParams := smithy.InvalidParamsError{Context: "InitiateMultipartUploadInput"} 1254 if v.AccountId == nil { 1255 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1256 } 1257 if v.VaultName == nil { 1258 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1259 } 1260 if invalidParams.Len() > 0 { 1261 return invalidParams 1262 } else { 1263 return nil 1264 } 1265} 1266 1267func validateOpInitiateVaultLockInput(v *InitiateVaultLockInput) error { 1268 if v == nil { 1269 return nil 1270 } 1271 invalidParams := smithy.InvalidParamsError{Context: "InitiateVaultLockInput"} 1272 if v.AccountId == nil { 1273 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1274 } 1275 if v.VaultName == nil { 1276 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1277 } 1278 if invalidParams.Len() > 0 { 1279 return invalidParams 1280 } else { 1281 return nil 1282 } 1283} 1284 1285func validateOpListJobsInput(v *ListJobsInput) error { 1286 if v == nil { 1287 return nil 1288 } 1289 invalidParams := smithy.InvalidParamsError{Context: "ListJobsInput"} 1290 if v.AccountId == nil { 1291 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1292 } 1293 if v.VaultName == nil { 1294 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1295 } 1296 if invalidParams.Len() > 0 { 1297 return invalidParams 1298 } else { 1299 return nil 1300 } 1301} 1302 1303func validateOpListMultipartUploadsInput(v *ListMultipartUploadsInput) error { 1304 if v == nil { 1305 return nil 1306 } 1307 invalidParams := smithy.InvalidParamsError{Context: "ListMultipartUploadsInput"} 1308 if v.AccountId == nil { 1309 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1310 } 1311 if v.VaultName == nil { 1312 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1313 } 1314 if invalidParams.Len() > 0 { 1315 return invalidParams 1316 } else { 1317 return nil 1318 } 1319} 1320 1321func validateOpListPartsInput(v *ListPartsInput) error { 1322 if v == nil { 1323 return nil 1324 } 1325 invalidParams := smithy.InvalidParamsError{Context: "ListPartsInput"} 1326 if v.AccountId == nil { 1327 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1328 } 1329 if v.VaultName == nil { 1330 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1331 } 1332 if v.UploadId == nil { 1333 invalidParams.Add(smithy.NewErrParamRequired("UploadId")) 1334 } 1335 if invalidParams.Len() > 0 { 1336 return invalidParams 1337 } else { 1338 return nil 1339 } 1340} 1341 1342func validateOpListProvisionedCapacityInput(v *ListProvisionedCapacityInput) error { 1343 if v == nil { 1344 return nil 1345 } 1346 invalidParams := smithy.InvalidParamsError{Context: "ListProvisionedCapacityInput"} 1347 if v.AccountId == nil { 1348 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1349 } 1350 if invalidParams.Len() > 0 { 1351 return invalidParams 1352 } else { 1353 return nil 1354 } 1355} 1356 1357func validateOpListTagsForVaultInput(v *ListTagsForVaultInput) error { 1358 if v == nil { 1359 return nil 1360 } 1361 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForVaultInput"} 1362 if v.AccountId == nil { 1363 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1364 } 1365 if v.VaultName == nil { 1366 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1367 } 1368 if invalidParams.Len() > 0 { 1369 return invalidParams 1370 } else { 1371 return nil 1372 } 1373} 1374 1375func validateOpListVaultsInput(v *ListVaultsInput) error { 1376 if v == nil { 1377 return nil 1378 } 1379 invalidParams := smithy.InvalidParamsError{Context: "ListVaultsInput"} 1380 if v.AccountId == nil { 1381 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1382 } 1383 if invalidParams.Len() > 0 { 1384 return invalidParams 1385 } else { 1386 return nil 1387 } 1388} 1389 1390func validateOpPurchaseProvisionedCapacityInput(v *PurchaseProvisionedCapacityInput) error { 1391 if v == nil { 1392 return nil 1393 } 1394 invalidParams := smithy.InvalidParamsError{Context: "PurchaseProvisionedCapacityInput"} 1395 if v.AccountId == nil { 1396 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1397 } 1398 if invalidParams.Len() > 0 { 1399 return invalidParams 1400 } else { 1401 return nil 1402 } 1403} 1404 1405func validateOpRemoveTagsFromVaultInput(v *RemoveTagsFromVaultInput) error { 1406 if v == nil { 1407 return nil 1408 } 1409 invalidParams := smithy.InvalidParamsError{Context: "RemoveTagsFromVaultInput"} 1410 if v.AccountId == nil { 1411 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1412 } 1413 if v.VaultName == nil { 1414 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1415 } 1416 if invalidParams.Len() > 0 { 1417 return invalidParams 1418 } else { 1419 return nil 1420 } 1421} 1422 1423func validateOpSetDataRetrievalPolicyInput(v *SetDataRetrievalPolicyInput) error { 1424 if v == nil { 1425 return nil 1426 } 1427 invalidParams := smithy.InvalidParamsError{Context: "SetDataRetrievalPolicyInput"} 1428 if v.AccountId == nil { 1429 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1430 } 1431 if invalidParams.Len() > 0 { 1432 return invalidParams 1433 } else { 1434 return nil 1435 } 1436} 1437 1438func validateOpSetVaultAccessPolicyInput(v *SetVaultAccessPolicyInput) error { 1439 if v == nil { 1440 return nil 1441 } 1442 invalidParams := smithy.InvalidParamsError{Context: "SetVaultAccessPolicyInput"} 1443 if v.AccountId == nil { 1444 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1445 } 1446 if v.VaultName == nil { 1447 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1448 } 1449 if invalidParams.Len() > 0 { 1450 return invalidParams 1451 } else { 1452 return nil 1453 } 1454} 1455 1456func validateOpSetVaultNotificationsInput(v *SetVaultNotificationsInput) error { 1457 if v == nil { 1458 return nil 1459 } 1460 invalidParams := smithy.InvalidParamsError{Context: "SetVaultNotificationsInput"} 1461 if v.AccountId == nil { 1462 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1463 } 1464 if v.VaultName == nil { 1465 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1466 } 1467 if invalidParams.Len() > 0 { 1468 return invalidParams 1469 } else { 1470 return nil 1471 } 1472} 1473 1474func validateOpUploadArchiveInput(v *UploadArchiveInput) error { 1475 if v == nil { 1476 return nil 1477 } 1478 invalidParams := smithy.InvalidParamsError{Context: "UploadArchiveInput"} 1479 if v.VaultName == nil { 1480 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1481 } 1482 if v.AccountId == nil { 1483 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1484 } 1485 if invalidParams.Len() > 0 { 1486 return invalidParams 1487 } else { 1488 return nil 1489 } 1490} 1491 1492func validateOpUploadMultipartPartInput(v *UploadMultipartPartInput) error { 1493 if v == nil { 1494 return nil 1495 } 1496 invalidParams := smithy.InvalidParamsError{Context: "UploadMultipartPartInput"} 1497 if v.AccountId == nil { 1498 invalidParams.Add(smithy.NewErrParamRequired("AccountId")) 1499 } 1500 if v.VaultName == nil { 1501 invalidParams.Add(smithy.NewErrParamRequired("VaultName")) 1502 } 1503 if v.UploadId == nil { 1504 invalidParams.Add(smithy.NewErrParamRequired("UploadId")) 1505 } 1506 if invalidParams.Len() > 0 { 1507 return invalidParams 1508 } else { 1509 return nil 1510 } 1511} 1512