@aws-sdk/client-glacier 3.504.0 → 3.507.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist-cjs/index.js +63 -953
  2. package/dist-es/protocols/Aws_restJson1.js +53 -943
  3. package/package.json +3 -3
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -434,7 +434,7 @@ export const se_UploadMultipartPartCommand = async (input, context) => {
434
434
  };
435
435
  export const de_AbortMultipartUploadCommand = async (output, context) => {
436
436
  if (output.statusCode !== 204 && output.statusCode >= 300) {
437
- return de_AbortMultipartUploadCommandError(output, context);
437
+ return de_CommandError(output, context);
438
438
  }
439
439
  const contents = map({
440
440
  $metadata: deserializeMetadata(output),
@@ -442,37 +442,9 @@ export const de_AbortMultipartUploadCommand = async (output, context) => {
442
442
  await collectBody(output.body, context);
443
443
  return contents;
444
444
  };
445
- const de_AbortMultipartUploadCommandError = async (output, context) => {
446
- const parsedOutput = {
447
- ...output,
448
- body: await parseErrorBody(output.body, context),
449
- };
450
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
451
- switch (errorCode) {
452
- case "InvalidParameterValueException":
453
- case "com.amazonaws.glacier#InvalidParameterValueException":
454
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
455
- case "MissingParameterValueException":
456
- case "com.amazonaws.glacier#MissingParameterValueException":
457
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
458
- case "ResourceNotFoundException":
459
- case "com.amazonaws.glacier#ResourceNotFoundException":
460
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
461
- case "ServiceUnavailableException":
462
- case "com.amazonaws.glacier#ServiceUnavailableException":
463
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
464
- default:
465
- const parsedBody = parsedOutput.body;
466
- return throwDefaultError({
467
- output,
468
- parsedBody,
469
- errorCode,
470
- });
471
- }
472
- };
473
445
  export const de_AbortVaultLockCommand = async (output, context) => {
474
446
  if (output.statusCode !== 204 && output.statusCode >= 300) {
475
- return de_AbortVaultLockCommandError(output, context);
447
+ return de_CommandError(output, context);
476
448
  }
477
449
  const contents = map({
478
450
  $metadata: deserializeMetadata(output),
@@ -480,37 +452,9 @@ export const de_AbortVaultLockCommand = async (output, context) => {
480
452
  await collectBody(output.body, context);
481
453
  return contents;
482
454
  };
483
- const de_AbortVaultLockCommandError = async (output, context) => {
484
- const parsedOutput = {
485
- ...output,
486
- body: await parseErrorBody(output.body, context),
487
- };
488
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
489
- switch (errorCode) {
490
- case "InvalidParameterValueException":
491
- case "com.amazonaws.glacier#InvalidParameterValueException":
492
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
493
- case "MissingParameterValueException":
494
- case "com.amazonaws.glacier#MissingParameterValueException":
495
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
496
- case "ResourceNotFoundException":
497
- case "com.amazonaws.glacier#ResourceNotFoundException":
498
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
499
- case "ServiceUnavailableException":
500
- case "com.amazonaws.glacier#ServiceUnavailableException":
501
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
502
- default:
503
- const parsedBody = parsedOutput.body;
504
- return throwDefaultError({
505
- output,
506
- parsedBody,
507
- errorCode,
508
- });
509
- }
510
- };
511
455
  export const de_AddTagsToVaultCommand = async (output, context) => {
512
456
  if (output.statusCode !== 204 && output.statusCode >= 300) {
513
- return de_AddTagsToVaultCommandError(output, context);
457
+ return de_CommandError(output, context);
514
458
  }
515
459
  const contents = map({
516
460
  $metadata: deserializeMetadata(output),
@@ -518,40 +462,9 @@ export const de_AddTagsToVaultCommand = async (output, context) => {
518
462
  await collectBody(output.body, context);
519
463
  return contents;
520
464
  };
521
- const de_AddTagsToVaultCommandError = async (output, context) => {
522
- const parsedOutput = {
523
- ...output,
524
- body: await parseErrorBody(output.body, context),
525
- };
526
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
527
- switch (errorCode) {
528
- case "InvalidParameterValueException":
529
- case "com.amazonaws.glacier#InvalidParameterValueException":
530
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
531
- case "LimitExceededException":
532
- case "com.amazonaws.glacier#LimitExceededException":
533
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
534
- case "MissingParameterValueException":
535
- case "com.amazonaws.glacier#MissingParameterValueException":
536
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
537
- case "ResourceNotFoundException":
538
- case "com.amazonaws.glacier#ResourceNotFoundException":
539
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
540
- case "ServiceUnavailableException":
541
- case "com.amazonaws.glacier#ServiceUnavailableException":
542
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
543
- default:
544
- const parsedBody = parsedOutput.body;
545
- return throwDefaultError({
546
- output,
547
- parsedBody,
548
- errorCode,
549
- });
550
- }
551
- };
552
465
  export const de_CompleteMultipartUploadCommand = async (output, context) => {
553
466
  if (output.statusCode !== 201 && output.statusCode >= 300) {
554
- return de_CompleteMultipartUploadCommandError(output, context);
467
+ return de_CommandError(output, context);
555
468
  }
556
469
  const contents = map({
557
470
  $metadata: deserializeMetadata(output),
@@ -562,37 +475,9 @@ export const de_CompleteMultipartUploadCommand = async (output, context) => {
562
475
  await collectBody(output.body, context);
563
476
  return contents;
564
477
  };
565
- const de_CompleteMultipartUploadCommandError = async (output, context) => {
566
- const parsedOutput = {
567
- ...output,
568
- body: await parseErrorBody(output.body, context),
569
- };
570
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
571
- switch (errorCode) {
572
- case "InvalidParameterValueException":
573
- case "com.amazonaws.glacier#InvalidParameterValueException":
574
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
575
- case "MissingParameterValueException":
576
- case "com.amazonaws.glacier#MissingParameterValueException":
577
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
578
- case "ResourceNotFoundException":
579
- case "com.amazonaws.glacier#ResourceNotFoundException":
580
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
581
- case "ServiceUnavailableException":
582
- case "com.amazonaws.glacier#ServiceUnavailableException":
583
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
584
- default:
585
- const parsedBody = parsedOutput.body;
586
- return throwDefaultError({
587
- output,
588
- parsedBody,
589
- errorCode,
590
- });
591
- }
592
- };
593
478
  export const de_CompleteVaultLockCommand = async (output, context) => {
594
479
  if (output.statusCode !== 204 && output.statusCode >= 300) {
595
- return de_CompleteVaultLockCommandError(output, context);
480
+ return de_CommandError(output, context);
596
481
  }
597
482
  const contents = map({
598
483
  $metadata: deserializeMetadata(output),
@@ -600,37 +485,9 @@ export const de_CompleteVaultLockCommand = async (output, context) => {
600
485
  await collectBody(output.body, context);
601
486
  return contents;
602
487
  };
603
- const de_CompleteVaultLockCommandError = async (output, context) => {
604
- const parsedOutput = {
605
- ...output,
606
- body: await parseErrorBody(output.body, context),
607
- };
608
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
609
- switch (errorCode) {
610
- case "InvalidParameterValueException":
611
- case "com.amazonaws.glacier#InvalidParameterValueException":
612
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
613
- case "MissingParameterValueException":
614
- case "com.amazonaws.glacier#MissingParameterValueException":
615
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
616
- case "ResourceNotFoundException":
617
- case "com.amazonaws.glacier#ResourceNotFoundException":
618
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
619
- case "ServiceUnavailableException":
620
- case "com.amazonaws.glacier#ServiceUnavailableException":
621
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
622
- default:
623
- const parsedBody = parsedOutput.body;
624
- return throwDefaultError({
625
- output,
626
- parsedBody,
627
- errorCode,
628
- });
629
- }
630
- };
631
488
  export const de_CreateVaultCommand = async (output, context) => {
632
489
  if (output.statusCode !== 201 && output.statusCode >= 300) {
633
- return de_CreateVaultCommandError(output, context);
490
+ return de_CommandError(output, context);
634
491
  }
635
492
  const contents = map({
636
493
  $metadata: deserializeMetadata(output),
@@ -639,37 +496,9 @@ export const de_CreateVaultCommand = async (output, context) => {
639
496
  await collectBody(output.body, context);
640
497
  return contents;
641
498
  };
642
- const de_CreateVaultCommandError = async (output, context) => {
643
- const parsedOutput = {
644
- ...output,
645
- body: await parseErrorBody(output.body, context),
646
- };
647
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
648
- switch (errorCode) {
649
- case "InvalidParameterValueException":
650
- case "com.amazonaws.glacier#InvalidParameterValueException":
651
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
652
- case "LimitExceededException":
653
- case "com.amazonaws.glacier#LimitExceededException":
654
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
655
- case "MissingParameterValueException":
656
- case "com.amazonaws.glacier#MissingParameterValueException":
657
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
658
- case "ServiceUnavailableException":
659
- case "com.amazonaws.glacier#ServiceUnavailableException":
660
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
661
- default:
662
- const parsedBody = parsedOutput.body;
663
- return throwDefaultError({
664
- output,
665
- parsedBody,
666
- errorCode,
667
- });
668
- }
669
- };
670
499
  export const de_DeleteArchiveCommand = async (output, context) => {
671
500
  if (output.statusCode !== 204 && output.statusCode >= 300) {
672
- return de_DeleteArchiveCommandError(output, context);
501
+ return de_CommandError(output, context);
673
502
  }
674
503
  const contents = map({
675
504
  $metadata: deserializeMetadata(output),
@@ -677,37 +506,9 @@ export const de_DeleteArchiveCommand = async (output, context) => {
677
506
  await collectBody(output.body, context);
678
507
  return contents;
679
508
  };
680
- const de_DeleteArchiveCommandError = async (output, context) => {
681
- const parsedOutput = {
682
- ...output,
683
- body: await parseErrorBody(output.body, context),
684
- };
685
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
686
- switch (errorCode) {
687
- case "InvalidParameterValueException":
688
- case "com.amazonaws.glacier#InvalidParameterValueException":
689
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
690
- case "MissingParameterValueException":
691
- case "com.amazonaws.glacier#MissingParameterValueException":
692
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
693
- case "ResourceNotFoundException":
694
- case "com.amazonaws.glacier#ResourceNotFoundException":
695
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
696
- case "ServiceUnavailableException":
697
- case "com.amazonaws.glacier#ServiceUnavailableException":
698
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
699
- default:
700
- const parsedBody = parsedOutput.body;
701
- return throwDefaultError({
702
- output,
703
- parsedBody,
704
- errorCode,
705
- });
706
- }
707
- };
708
509
  export const de_DeleteVaultCommand = async (output, context) => {
709
510
  if (output.statusCode !== 204 && output.statusCode >= 300) {
710
- return de_DeleteVaultCommandError(output, context);
511
+ return de_CommandError(output, context);
711
512
  }
712
513
  const contents = map({
713
514
  $metadata: deserializeMetadata(output),
@@ -715,37 +516,9 @@ export const de_DeleteVaultCommand = async (output, context) => {
715
516
  await collectBody(output.body, context);
716
517
  return contents;
717
518
  };
718
- const de_DeleteVaultCommandError = async (output, context) => {
719
- const parsedOutput = {
720
- ...output,
721
- body: await parseErrorBody(output.body, context),
722
- };
723
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
724
- switch (errorCode) {
725
- case "InvalidParameterValueException":
726
- case "com.amazonaws.glacier#InvalidParameterValueException":
727
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
728
- case "MissingParameterValueException":
729
- case "com.amazonaws.glacier#MissingParameterValueException":
730
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
731
- case "ResourceNotFoundException":
732
- case "com.amazonaws.glacier#ResourceNotFoundException":
733
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
734
- case "ServiceUnavailableException":
735
- case "com.amazonaws.glacier#ServiceUnavailableException":
736
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
737
- default:
738
- const parsedBody = parsedOutput.body;
739
- return throwDefaultError({
740
- output,
741
- parsedBody,
742
- errorCode,
743
- });
744
- }
745
- };
746
519
  export const de_DeleteVaultAccessPolicyCommand = async (output, context) => {
747
520
  if (output.statusCode !== 204 && output.statusCode >= 300) {
748
- return de_DeleteVaultAccessPolicyCommandError(output, context);
521
+ return de_CommandError(output, context);
749
522
  }
750
523
  const contents = map({
751
524
  $metadata: deserializeMetadata(output),
@@ -753,37 +526,9 @@ export const de_DeleteVaultAccessPolicyCommand = async (output, context) => {
753
526
  await collectBody(output.body, context);
754
527
  return contents;
755
528
  };
756
- const de_DeleteVaultAccessPolicyCommandError = async (output, context) => {
757
- const parsedOutput = {
758
- ...output,
759
- body: await parseErrorBody(output.body, context),
760
- };
761
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
762
- switch (errorCode) {
763
- case "InvalidParameterValueException":
764
- case "com.amazonaws.glacier#InvalidParameterValueException":
765
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
766
- case "MissingParameterValueException":
767
- case "com.amazonaws.glacier#MissingParameterValueException":
768
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
769
- case "ResourceNotFoundException":
770
- case "com.amazonaws.glacier#ResourceNotFoundException":
771
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
772
- case "ServiceUnavailableException":
773
- case "com.amazonaws.glacier#ServiceUnavailableException":
774
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
775
- default:
776
- const parsedBody = parsedOutput.body;
777
- return throwDefaultError({
778
- output,
779
- parsedBody,
780
- errorCode,
781
- });
782
- }
783
- };
784
529
  export const de_DeleteVaultNotificationsCommand = async (output, context) => {
785
530
  if (output.statusCode !== 204 && output.statusCode >= 300) {
786
- return de_DeleteVaultNotificationsCommandError(output, context);
531
+ return de_CommandError(output, context);
787
532
  }
788
533
  const contents = map({
789
534
  $metadata: deserializeMetadata(output),
@@ -791,37 +536,9 @@ export const de_DeleteVaultNotificationsCommand = async (output, context) => {
791
536
  await collectBody(output.body, context);
792
537
  return contents;
793
538
  };
794
- const de_DeleteVaultNotificationsCommandError = async (output, context) => {
795
- const parsedOutput = {
796
- ...output,
797
- body: await parseErrorBody(output.body, context),
798
- };
799
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
800
- switch (errorCode) {
801
- case "InvalidParameterValueException":
802
- case "com.amazonaws.glacier#InvalidParameterValueException":
803
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
804
- case "MissingParameterValueException":
805
- case "com.amazonaws.glacier#MissingParameterValueException":
806
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
807
- case "ResourceNotFoundException":
808
- case "com.amazonaws.glacier#ResourceNotFoundException":
809
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
810
- case "ServiceUnavailableException":
811
- case "com.amazonaws.glacier#ServiceUnavailableException":
812
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
813
- default:
814
- const parsedBody = parsedOutput.body;
815
- return throwDefaultError({
816
- output,
817
- parsedBody,
818
- errorCode,
819
- });
820
- }
821
- };
822
539
  export const de_DescribeJobCommand = async (output, context) => {
823
540
  if (output.statusCode !== 200 && output.statusCode >= 300) {
824
- return de_DescribeJobCommandError(output, context);
541
+ return de_CommandError(output, context);
825
542
  }
826
543
  const contents = map({
827
544
  $metadata: deserializeMetadata(output),
@@ -853,37 +570,9 @@ export const de_DescribeJobCommand = async (output, context) => {
853
570
  Object.assign(contents, doc);
854
571
  return contents;
855
572
  };
856
- const de_DescribeJobCommandError = async (output, context) => {
857
- const parsedOutput = {
858
- ...output,
859
- body: await parseErrorBody(output.body, context),
860
- };
861
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
862
- switch (errorCode) {
863
- case "InvalidParameterValueException":
864
- case "com.amazonaws.glacier#InvalidParameterValueException":
865
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
866
- case "MissingParameterValueException":
867
- case "com.amazonaws.glacier#MissingParameterValueException":
868
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
869
- case "ResourceNotFoundException":
870
- case "com.amazonaws.glacier#ResourceNotFoundException":
871
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
872
- case "ServiceUnavailableException":
873
- case "com.amazonaws.glacier#ServiceUnavailableException":
874
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
875
- default:
876
- const parsedBody = parsedOutput.body;
877
- return throwDefaultError({
878
- output,
879
- parsedBody,
880
- errorCode,
881
- });
882
- }
883
- };
884
573
  export const de_DescribeVaultCommand = async (output, context) => {
885
574
  if (output.statusCode !== 200 && output.statusCode >= 300) {
886
- return de_DescribeVaultCommandError(output, context);
575
+ return de_CommandError(output, context);
887
576
  }
888
577
  const contents = map({
889
578
  $metadata: deserializeMetadata(output),
@@ -900,37 +589,9 @@ export const de_DescribeVaultCommand = async (output, context) => {
900
589
  Object.assign(contents, doc);
901
590
  return contents;
902
591
  };
903
- const de_DescribeVaultCommandError = async (output, context) => {
904
- const parsedOutput = {
905
- ...output,
906
- body: await parseErrorBody(output.body, context),
907
- };
908
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
909
- switch (errorCode) {
910
- case "InvalidParameterValueException":
911
- case "com.amazonaws.glacier#InvalidParameterValueException":
912
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
913
- case "MissingParameterValueException":
914
- case "com.amazonaws.glacier#MissingParameterValueException":
915
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
916
- case "ResourceNotFoundException":
917
- case "com.amazonaws.glacier#ResourceNotFoundException":
918
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
919
- case "ServiceUnavailableException":
920
- case "com.amazonaws.glacier#ServiceUnavailableException":
921
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
922
- default:
923
- const parsedBody = parsedOutput.body;
924
- return throwDefaultError({
925
- output,
926
- parsedBody,
927
- errorCode,
928
- });
929
- }
930
- };
931
592
  export const de_GetDataRetrievalPolicyCommand = async (output, context) => {
932
593
  if (output.statusCode !== 200 && output.statusCode >= 300) {
933
- return de_GetDataRetrievalPolicyCommandError(output, context);
594
+ return de_CommandError(output, context);
934
595
  }
935
596
  const contents = map({
936
597
  $metadata: deserializeMetadata(output),
@@ -942,34 +603,9 @@ export const de_GetDataRetrievalPolicyCommand = async (output, context) => {
942
603
  Object.assign(contents, doc);
943
604
  return contents;
944
605
  };
945
- const de_GetDataRetrievalPolicyCommandError = async (output, context) => {
946
- const parsedOutput = {
947
- ...output,
948
- body: await parseErrorBody(output.body, context),
949
- };
950
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
951
- switch (errorCode) {
952
- case "InvalidParameterValueException":
953
- case "com.amazonaws.glacier#InvalidParameterValueException":
954
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
955
- case "MissingParameterValueException":
956
- case "com.amazonaws.glacier#MissingParameterValueException":
957
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
958
- case "ServiceUnavailableException":
959
- case "com.amazonaws.glacier#ServiceUnavailableException":
960
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
961
- default:
962
- const parsedBody = parsedOutput.body;
963
- return throwDefaultError({
964
- output,
965
- parsedBody,
966
- errorCode,
967
- });
968
- }
969
- };
970
606
  export const de_GetJobOutputCommand = async (output, context) => {
971
607
  if (output.statusCode !== 200 && output.statusCode >= 300) {
972
- return de_GetJobOutputCommandError(output, context);
608
+ return de_CommandError(output, context);
973
609
  }
974
610
  const contents = map({
975
611
  $metadata: deserializeMetadata(output),
@@ -980,44 +616,16 @@ export const de_GetJobOutputCommand = async (output, context) => {
980
616
  [_aD]: [, output.headers[_xaad]],
981
617
  });
982
618
  const data = output.body;
983
- context.sdkStreamMixin(data);
984
- contents.body = data;
985
- map(contents, {
986
- status: [, output.statusCode],
987
- });
988
- return contents;
989
- };
990
- const de_GetJobOutputCommandError = async (output, context) => {
991
- const parsedOutput = {
992
- ...output,
993
- body: await parseErrorBody(output.body, context),
994
- };
995
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
996
- switch (errorCode) {
997
- case "InvalidParameterValueException":
998
- case "com.amazonaws.glacier#InvalidParameterValueException":
999
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1000
- case "MissingParameterValueException":
1001
- case "com.amazonaws.glacier#MissingParameterValueException":
1002
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1003
- case "ResourceNotFoundException":
1004
- case "com.amazonaws.glacier#ResourceNotFoundException":
1005
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1006
- case "ServiceUnavailableException":
1007
- case "com.amazonaws.glacier#ServiceUnavailableException":
1008
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1009
- default:
1010
- const parsedBody = parsedOutput.body;
1011
- return throwDefaultError({
1012
- output,
1013
- parsedBody,
1014
- errorCode,
1015
- });
1016
- }
619
+ context.sdkStreamMixin(data);
620
+ contents.body = data;
621
+ map(contents, {
622
+ status: [, output.statusCode],
623
+ });
624
+ return contents;
1017
625
  };
1018
626
  export const de_GetVaultAccessPolicyCommand = async (output, context) => {
1019
627
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1020
- return de_GetVaultAccessPolicyCommandError(output, context);
628
+ return de_CommandError(output, context);
1021
629
  }
1022
630
  const contents = map({
1023
631
  $metadata: deserializeMetadata(output),
@@ -1026,37 +634,9 @@ export const de_GetVaultAccessPolicyCommand = async (output, context) => {
1026
634
  contents.policy = _json(data);
1027
635
  return contents;
1028
636
  };
1029
- const de_GetVaultAccessPolicyCommandError = async (output, context) => {
1030
- const parsedOutput = {
1031
- ...output,
1032
- body: await parseErrorBody(output.body, context),
1033
- };
1034
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1035
- switch (errorCode) {
1036
- case "InvalidParameterValueException":
1037
- case "com.amazonaws.glacier#InvalidParameterValueException":
1038
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1039
- case "MissingParameterValueException":
1040
- case "com.amazonaws.glacier#MissingParameterValueException":
1041
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1042
- case "ResourceNotFoundException":
1043
- case "com.amazonaws.glacier#ResourceNotFoundException":
1044
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1045
- case "ServiceUnavailableException":
1046
- case "com.amazonaws.glacier#ServiceUnavailableException":
1047
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1048
- default:
1049
- const parsedBody = parsedOutput.body;
1050
- return throwDefaultError({
1051
- output,
1052
- parsedBody,
1053
- errorCode,
1054
- });
1055
- }
1056
- };
1057
637
  export const de_GetVaultLockCommand = async (output, context) => {
1058
638
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1059
- return de_GetVaultLockCommandError(output, context);
639
+ return de_CommandError(output, context);
1060
640
  }
1061
641
  const contents = map({
1062
642
  $metadata: deserializeMetadata(output),
@@ -1071,37 +651,9 @@ export const de_GetVaultLockCommand = async (output, context) => {
1071
651
  Object.assign(contents, doc);
1072
652
  return contents;
1073
653
  };
1074
- const de_GetVaultLockCommandError = async (output, context) => {
1075
- const parsedOutput = {
1076
- ...output,
1077
- body: await parseErrorBody(output.body, context),
1078
- };
1079
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1080
- switch (errorCode) {
1081
- case "InvalidParameterValueException":
1082
- case "com.amazonaws.glacier#InvalidParameterValueException":
1083
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1084
- case "MissingParameterValueException":
1085
- case "com.amazonaws.glacier#MissingParameterValueException":
1086
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1087
- case "ResourceNotFoundException":
1088
- case "com.amazonaws.glacier#ResourceNotFoundException":
1089
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1090
- case "ServiceUnavailableException":
1091
- case "com.amazonaws.glacier#ServiceUnavailableException":
1092
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1093
- default:
1094
- const parsedBody = parsedOutput.body;
1095
- return throwDefaultError({
1096
- output,
1097
- parsedBody,
1098
- errorCode,
1099
- });
1100
- }
1101
- };
1102
654
  export const de_GetVaultNotificationsCommand = async (output, context) => {
1103
655
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1104
- return de_GetVaultNotificationsCommandError(output, context);
656
+ return de_CommandError(output, context);
1105
657
  }
1106
658
  const contents = map({
1107
659
  $metadata: deserializeMetadata(output),
@@ -1110,37 +662,9 @@ export const de_GetVaultNotificationsCommand = async (output, context) => {
1110
662
  contents.vaultNotificationConfig = _json(data);
1111
663
  return contents;
1112
664
  };
1113
- const de_GetVaultNotificationsCommandError = async (output, context) => {
1114
- const parsedOutput = {
1115
- ...output,
1116
- body: await parseErrorBody(output.body, context),
1117
- };
1118
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1119
- switch (errorCode) {
1120
- case "InvalidParameterValueException":
1121
- case "com.amazonaws.glacier#InvalidParameterValueException":
1122
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1123
- case "MissingParameterValueException":
1124
- case "com.amazonaws.glacier#MissingParameterValueException":
1125
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1126
- case "ResourceNotFoundException":
1127
- case "com.amazonaws.glacier#ResourceNotFoundException":
1128
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1129
- case "ServiceUnavailableException":
1130
- case "com.amazonaws.glacier#ServiceUnavailableException":
1131
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1132
- default:
1133
- const parsedBody = parsedOutput.body;
1134
- return throwDefaultError({
1135
- output,
1136
- parsedBody,
1137
- errorCode,
1138
- });
1139
- }
1140
- };
1141
665
  export const de_InitiateJobCommand = async (output, context) => {
1142
666
  if (output.statusCode !== 202 && output.statusCode >= 300) {
1143
- return de_InitiateJobCommandError(output, context);
667
+ return de_CommandError(output, context);
1144
668
  }
1145
669
  const contents = map({
1146
670
  $metadata: deserializeMetadata(output),
@@ -1151,43 +675,9 @@ export const de_InitiateJobCommand = async (output, context) => {
1151
675
  await collectBody(output.body, context);
1152
676
  return contents;
1153
677
  };
1154
- const de_InitiateJobCommandError = async (output, context) => {
1155
- const parsedOutput = {
1156
- ...output,
1157
- body: await parseErrorBody(output.body, context),
1158
- };
1159
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1160
- switch (errorCode) {
1161
- case "InsufficientCapacityException":
1162
- case "com.amazonaws.glacier#InsufficientCapacityException":
1163
- throw await de_InsufficientCapacityExceptionRes(parsedOutput, context);
1164
- case "InvalidParameterValueException":
1165
- case "com.amazonaws.glacier#InvalidParameterValueException":
1166
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1167
- case "MissingParameterValueException":
1168
- case "com.amazonaws.glacier#MissingParameterValueException":
1169
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1170
- case "PolicyEnforcedException":
1171
- case "com.amazonaws.glacier#PolicyEnforcedException":
1172
- throw await de_PolicyEnforcedExceptionRes(parsedOutput, context);
1173
- case "ResourceNotFoundException":
1174
- case "com.amazonaws.glacier#ResourceNotFoundException":
1175
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1176
- case "ServiceUnavailableException":
1177
- case "com.amazonaws.glacier#ServiceUnavailableException":
1178
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1179
- default:
1180
- const parsedBody = parsedOutput.body;
1181
- return throwDefaultError({
1182
- output,
1183
- parsedBody,
1184
- errorCode,
1185
- });
1186
- }
1187
- };
1188
678
  export const de_InitiateMultipartUploadCommand = async (output, context) => {
1189
679
  if (output.statusCode !== 201 && output.statusCode >= 300) {
1190
- return de_InitiateMultipartUploadCommandError(output, context);
680
+ return de_CommandError(output, context);
1191
681
  }
1192
682
  const contents = map({
1193
683
  $metadata: deserializeMetadata(output),
@@ -1197,37 +687,9 @@ export const de_InitiateMultipartUploadCommand = async (output, context) => {
1197
687
  await collectBody(output.body, context);
1198
688
  return contents;
1199
689
  };
1200
- const de_InitiateMultipartUploadCommandError = async (output, context) => {
1201
- const parsedOutput = {
1202
- ...output,
1203
- body: await parseErrorBody(output.body, context),
1204
- };
1205
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1206
- switch (errorCode) {
1207
- case "InvalidParameterValueException":
1208
- case "com.amazonaws.glacier#InvalidParameterValueException":
1209
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1210
- case "MissingParameterValueException":
1211
- case "com.amazonaws.glacier#MissingParameterValueException":
1212
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1213
- case "ResourceNotFoundException":
1214
- case "com.amazonaws.glacier#ResourceNotFoundException":
1215
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1216
- case "ServiceUnavailableException":
1217
- case "com.amazonaws.glacier#ServiceUnavailableException":
1218
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1219
- default:
1220
- const parsedBody = parsedOutput.body;
1221
- return throwDefaultError({
1222
- output,
1223
- parsedBody,
1224
- errorCode,
1225
- });
1226
- }
1227
- };
1228
690
  export const de_InitiateVaultLockCommand = async (output, context) => {
1229
691
  if (output.statusCode !== 201 && output.statusCode >= 300) {
1230
- return de_InitiateVaultLockCommandError(output, context);
692
+ return de_CommandError(output, context);
1231
693
  }
1232
694
  const contents = map({
1233
695
  $metadata: deserializeMetadata(output),
@@ -1236,37 +698,9 @@ export const de_InitiateVaultLockCommand = async (output, context) => {
1236
698
  await collectBody(output.body, context);
1237
699
  return contents;
1238
700
  };
1239
- const de_InitiateVaultLockCommandError = async (output, context) => {
1240
- const parsedOutput = {
1241
- ...output,
1242
- body: await parseErrorBody(output.body, context),
1243
- };
1244
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1245
- switch (errorCode) {
1246
- case "InvalidParameterValueException":
1247
- case "com.amazonaws.glacier#InvalidParameterValueException":
1248
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1249
- case "MissingParameterValueException":
1250
- case "com.amazonaws.glacier#MissingParameterValueException":
1251
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1252
- case "ResourceNotFoundException":
1253
- case "com.amazonaws.glacier#ResourceNotFoundException":
1254
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1255
- case "ServiceUnavailableException":
1256
- case "com.amazonaws.glacier#ServiceUnavailableException":
1257
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1258
- default:
1259
- const parsedBody = parsedOutput.body;
1260
- return throwDefaultError({
1261
- output,
1262
- parsedBody,
1263
- errorCode,
1264
- });
1265
- }
1266
- };
1267
701
  export const de_ListJobsCommand = async (output, context) => {
1268
702
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1269
- return de_ListJobsCommandError(output, context);
703
+ return de_CommandError(output, context);
1270
704
  }
1271
705
  const contents = map({
1272
706
  $metadata: deserializeMetadata(output),
@@ -1279,37 +713,9 @@ export const de_ListJobsCommand = async (output, context) => {
1279
713
  Object.assign(contents, doc);
1280
714
  return contents;
1281
715
  };
1282
- const de_ListJobsCommandError = async (output, context) => {
1283
- const parsedOutput = {
1284
- ...output,
1285
- body: await parseErrorBody(output.body, context),
1286
- };
1287
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1288
- switch (errorCode) {
1289
- case "InvalidParameterValueException":
1290
- case "com.amazonaws.glacier#InvalidParameterValueException":
1291
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1292
- case "MissingParameterValueException":
1293
- case "com.amazonaws.glacier#MissingParameterValueException":
1294
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1295
- case "ResourceNotFoundException":
1296
- case "com.amazonaws.glacier#ResourceNotFoundException":
1297
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1298
- case "ServiceUnavailableException":
1299
- case "com.amazonaws.glacier#ServiceUnavailableException":
1300
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1301
- default:
1302
- const parsedBody = parsedOutput.body;
1303
- return throwDefaultError({
1304
- output,
1305
- parsedBody,
1306
- errorCode,
1307
- });
1308
- }
1309
- };
1310
716
  export const de_ListMultipartUploadsCommand = async (output, context) => {
1311
717
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1312
- return de_ListMultipartUploadsCommandError(output, context);
718
+ return de_CommandError(output, context);
1313
719
  }
1314
720
  const contents = map({
1315
721
  $metadata: deserializeMetadata(output),
@@ -1322,37 +728,9 @@ export const de_ListMultipartUploadsCommand = async (output, context) => {
1322
728
  Object.assign(contents, doc);
1323
729
  return contents;
1324
730
  };
1325
- const de_ListMultipartUploadsCommandError = async (output, context) => {
1326
- const parsedOutput = {
1327
- ...output,
1328
- body: await parseErrorBody(output.body, context),
1329
- };
1330
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1331
- switch (errorCode) {
1332
- case "InvalidParameterValueException":
1333
- case "com.amazonaws.glacier#InvalidParameterValueException":
1334
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1335
- case "MissingParameterValueException":
1336
- case "com.amazonaws.glacier#MissingParameterValueException":
1337
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1338
- case "ResourceNotFoundException":
1339
- case "com.amazonaws.glacier#ResourceNotFoundException":
1340
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1341
- case "ServiceUnavailableException":
1342
- case "com.amazonaws.glacier#ServiceUnavailableException":
1343
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1344
- default:
1345
- const parsedBody = parsedOutput.body;
1346
- return throwDefaultError({
1347
- output,
1348
- parsedBody,
1349
- errorCode,
1350
- });
1351
- }
1352
- };
1353
731
  export const de_ListPartsCommand = async (output, context) => {
1354
732
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1355
- return de_ListPartsCommandError(output, context);
733
+ return de_CommandError(output, context);
1356
734
  }
1357
735
  const contents = map({
1358
736
  $metadata: deserializeMetadata(output),
@@ -1368,39 +746,11 @@ export const de_ListPartsCommand = async (output, context) => {
1368
746
  VaultARN: __expectString,
1369
747
  });
1370
748
  Object.assign(contents, doc);
1371
- return contents;
1372
- };
1373
- const de_ListPartsCommandError = async (output, context) => {
1374
- const parsedOutput = {
1375
- ...output,
1376
- body: await parseErrorBody(output.body, context),
1377
- };
1378
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1379
- switch (errorCode) {
1380
- case "InvalidParameterValueException":
1381
- case "com.amazonaws.glacier#InvalidParameterValueException":
1382
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1383
- case "MissingParameterValueException":
1384
- case "com.amazonaws.glacier#MissingParameterValueException":
1385
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1386
- case "ResourceNotFoundException":
1387
- case "com.amazonaws.glacier#ResourceNotFoundException":
1388
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1389
- case "ServiceUnavailableException":
1390
- case "com.amazonaws.glacier#ServiceUnavailableException":
1391
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1392
- default:
1393
- const parsedBody = parsedOutput.body;
1394
- return throwDefaultError({
1395
- output,
1396
- parsedBody,
1397
- errorCode,
1398
- });
1399
- }
749
+ return contents;
1400
750
  };
1401
751
  export const de_ListProvisionedCapacityCommand = async (output, context) => {
1402
752
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1403
- return de_ListProvisionedCapacityCommandError(output, context);
753
+ return de_CommandError(output, context);
1404
754
  }
1405
755
  const contents = map({
1406
756
  $metadata: deserializeMetadata(output),
@@ -1412,34 +762,9 @@ export const de_ListProvisionedCapacityCommand = async (output, context) => {
1412
762
  Object.assign(contents, doc);
1413
763
  return contents;
1414
764
  };
1415
- const de_ListProvisionedCapacityCommandError = async (output, context) => {
1416
- const parsedOutput = {
1417
- ...output,
1418
- body: await parseErrorBody(output.body, context),
1419
- };
1420
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1421
- switch (errorCode) {
1422
- case "InvalidParameterValueException":
1423
- case "com.amazonaws.glacier#InvalidParameterValueException":
1424
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1425
- case "MissingParameterValueException":
1426
- case "com.amazonaws.glacier#MissingParameterValueException":
1427
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1428
- case "ServiceUnavailableException":
1429
- case "com.amazonaws.glacier#ServiceUnavailableException":
1430
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1431
- default:
1432
- const parsedBody = parsedOutput.body;
1433
- return throwDefaultError({
1434
- output,
1435
- parsedBody,
1436
- errorCode,
1437
- });
1438
- }
1439
- };
1440
765
  export const de_ListTagsForVaultCommand = async (output, context) => {
1441
766
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1442
- return de_ListTagsForVaultCommandError(output, context);
767
+ return de_CommandError(output, context);
1443
768
  }
1444
769
  const contents = map({
1445
770
  $metadata: deserializeMetadata(output),
@@ -1451,37 +776,9 @@ export const de_ListTagsForVaultCommand = async (output, context) => {
1451
776
  Object.assign(contents, doc);
1452
777
  return contents;
1453
778
  };
1454
- const de_ListTagsForVaultCommandError = async (output, context) => {
1455
- const parsedOutput = {
1456
- ...output,
1457
- body: await parseErrorBody(output.body, context),
1458
- };
1459
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1460
- switch (errorCode) {
1461
- case "InvalidParameterValueException":
1462
- case "com.amazonaws.glacier#InvalidParameterValueException":
1463
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1464
- case "MissingParameterValueException":
1465
- case "com.amazonaws.glacier#MissingParameterValueException":
1466
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1467
- case "ResourceNotFoundException":
1468
- case "com.amazonaws.glacier#ResourceNotFoundException":
1469
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1470
- case "ServiceUnavailableException":
1471
- case "com.amazonaws.glacier#ServiceUnavailableException":
1472
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1473
- default:
1474
- const parsedBody = parsedOutput.body;
1475
- return throwDefaultError({
1476
- output,
1477
- parsedBody,
1478
- errorCode,
1479
- });
1480
- }
1481
- };
1482
779
  export const de_ListVaultsCommand = async (output, context) => {
1483
780
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1484
- return de_ListVaultsCommandError(output, context);
781
+ return de_CommandError(output, context);
1485
782
  }
1486
783
  const contents = map({
1487
784
  $metadata: deserializeMetadata(output),
@@ -1494,37 +791,9 @@ export const de_ListVaultsCommand = async (output, context) => {
1494
791
  Object.assign(contents, doc);
1495
792
  return contents;
1496
793
  };
1497
- const de_ListVaultsCommandError = async (output, context) => {
1498
- const parsedOutput = {
1499
- ...output,
1500
- body: await parseErrorBody(output.body, context),
1501
- };
1502
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1503
- switch (errorCode) {
1504
- case "InvalidParameterValueException":
1505
- case "com.amazonaws.glacier#InvalidParameterValueException":
1506
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1507
- case "MissingParameterValueException":
1508
- case "com.amazonaws.glacier#MissingParameterValueException":
1509
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1510
- case "ResourceNotFoundException":
1511
- case "com.amazonaws.glacier#ResourceNotFoundException":
1512
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1513
- case "ServiceUnavailableException":
1514
- case "com.amazonaws.glacier#ServiceUnavailableException":
1515
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1516
- default:
1517
- const parsedBody = parsedOutput.body;
1518
- return throwDefaultError({
1519
- output,
1520
- parsedBody,
1521
- errorCode,
1522
- });
1523
- }
1524
- };
1525
794
  export const de_PurchaseProvisionedCapacityCommand = async (output, context) => {
1526
795
  if (output.statusCode !== 201 && output.statusCode >= 300) {
1527
- return de_PurchaseProvisionedCapacityCommandError(output, context);
796
+ return de_CommandError(output, context);
1528
797
  }
1529
798
  const contents = map({
1530
799
  $metadata: deserializeMetadata(output),
@@ -1533,37 +802,9 @@ export const de_PurchaseProvisionedCapacityCommand = async (output, context) =>
1533
802
  await collectBody(output.body, context);
1534
803
  return contents;
1535
804
  };
1536
- const de_PurchaseProvisionedCapacityCommandError = async (output, context) => {
1537
- const parsedOutput = {
1538
- ...output,
1539
- body: await parseErrorBody(output.body, context),
1540
- };
1541
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1542
- switch (errorCode) {
1543
- case "InvalidParameterValueException":
1544
- case "com.amazonaws.glacier#InvalidParameterValueException":
1545
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1546
- case "LimitExceededException":
1547
- case "com.amazonaws.glacier#LimitExceededException":
1548
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1549
- case "MissingParameterValueException":
1550
- case "com.amazonaws.glacier#MissingParameterValueException":
1551
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1552
- case "ServiceUnavailableException":
1553
- case "com.amazonaws.glacier#ServiceUnavailableException":
1554
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1555
- default:
1556
- const parsedBody = parsedOutput.body;
1557
- return throwDefaultError({
1558
- output,
1559
- parsedBody,
1560
- errorCode,
1561
- });
1562
- }
1563
- };
1564
805
  export const de_RemoveTagsFromVaultCommand = async (output, context) => {
1565
806
  if (output.statusCode !== 204 && output.statusCode >= 300) {
1566
- return de_RemoveTagsFromVaultCommandError(output, context);
807
+ return de_CommandError(output, context);
1567
808
  }
1568
809
  const contents = map({
1569
810
  $metadata: deserializeMetadata(output),
@@ -1571,37 +812,9 @@ export const de_RemoveTagsFromVaultCommand = async (output, context) => {
1571
812
  await collectBody(output.body, context);
1572
813
  return contents;
1573
814
  };
1574
- const de_RemoveTagsFromVaultCommandError = async (output, context) => {
1575
- const parsedOutput = {
1576
- ...output,
1577
- body: await parseErrorBody(output.body, context),
1578
- };
1579
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1580
- switch (errorCode) {
1581
- case "InvalidParameterValueException":
1582
- case "com.amazonaws.glacier#InvalidParameterValueException":
1583
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1584
- case "MissingParameterValueException":
1585
- case "com.amazonaws.glacier#MissingParameterValueException":
1586
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1587
- case "ResourceNotFoundException":
1588
- case "com.amazonaws.glacier#ResourceNotFoundException":
1589
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1590
- case "ServiceUnavailableException":
1591
- case "com.amazonaws.glacier#ServiceUnavailableException":
1592
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1593
- default:
1594
- const parsedBody = parsedOutput.body;
1595
- return throwDefaultError({
1596
- output,
1597
- parsedBody,
1598
- errorCode,
1599
- });
1600
- }
1601
- };
1602
815
  export const de_SetDataRetrievalPolicyCommand = async (output, context) => {
1603
816
  if (output.statusCode !== 204 && output.statusCode >= 300) {
1604
- return de_SetDataRetrievalPolicyCommandError(output, context);
817
+ return de_CommandError(output, context);
1605
818
  }
1606
819
  const contents = map({
1607
820
  $metadata: deserializeMetadata(output),
@@ -1609,34 +822,9 @@ export const de_SetDataRetrievalPolicyCommand = async (output, context) => {
1609
822
  await collectBody(output.body, context);
1610
823
  return contents;
1611
824
  };
1612
- const de_SetDataRetrievalPolicyCommandError = async (output, context) => {
1613
- const parsedOutput = {
1614
- ...output,
1615
- body: await parseErrorBody(output.body, context),
1616
- };
1617
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1618
- switch (errorCode) {
1619
- case "InvalidParameterValueException":
1620
- case "com.amazonaws.glacier#InvalidParameterValueException":
1621
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1622
- case "MissingParameterValueException":
1623
- case "com.amazonaws.glacier#MissingParameterValueException":
1624
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1625
- case "ServiceUnavailableException":
1626
- case "com.amazonaws.glacier#ServiceUnavailableException":
1627
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1628
- default:
1629
- const parsedBody = parsedOutput.body;
1630
- return throwDefaultError({
1631
- output,
1632
- parsedBody,
1633
- errorCode,
1634
- });
1635
- }
1636
- };
1637
825
  export const de_SetVaultAccessPolicyCommand = async (output, context) => {
1638
826
  if (output.statusCode !== 204 && output.statusCode >= 300) {
1639
- return de_SetVaultAccessPolicyCommandError(output, context);
827
+ return de_CommandError(output, context);
1640
828
  }
1641
829
  const contents = map({
1642
830
  $metadata: deserializeMetadata(output),
@@ -1644,37 +832,9 @@ export const de_SetVaultAccessPolicyCommand = async (output, context) => {
1644
832
  await collectBody(output.body, context);
1645
833
  return contents;
1646
834
  };
1647
- const de_SetVaultAccessPolicyCommandError = async (output, context) => {
1648
- const parsedOutput = {
1649
- ...output,
1650
- body: await parseErrorBody(output.body, context),
1651
- };
1652
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1653
- switch (errorCode) {
1654
- case "InvalidParameterValueException":
1655
- case "com.amazonaws.glacier#InvalidParameterValueException":
1656
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1657
- case "MissingParameterValueException":
1658
- case "com.amazonaws.glacier#MissingParameterValueException":
1659
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1660
- case "ResourceNotFoundException":
1661
- case "com.amazonaws.glacier#ResourceNotFoundException":
1662
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1663
- case "ServiceUnavailableException":
1664
- case "com.amazonaws.glacier#ServiceUnavailableException":
1665
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1666
- default:
1667
- const parsedBody = parsedOutput.body;
1668
- return throwDefaultError({
1669
- output,
1670
- parsedBody,
1671
- errorCode,
1672
- });
1673
- }
1674
- };
1675
835
  export const de_SetVaultNotificationsCommand = async (output, context) => {
1676
836
  if (output.statusCode !== 204 && output.statusCode >= 300) {
1677
- return de_SetVaultNotificationsCommandError(output, context);
837
+ return de_CommandError(output, context);
1678
838
  }
1679
839
  const contents = map({
1680
840
  $metadata: deserializeMetadata(output),
@@ -1682,37 +842,9 @@ export const de_SetVaultNotificationsCommand = async (output, context) => {
1682
842
  await collectBody(output.body, context);
1683
843
  return contents;
1684
844
  };
1685
- const de_SetVaultNotificationsCommandError = async (output, context) => {
1686
- const parsedOutput = {
1687
- ...output,
1688
- body: await parseErrorBody(output.body, context),
1689
- };
1690
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1691
- switch (errorCode) {
1692
- case "InvalidParameterValueException":
1693
- case "com.amazonaws.glacier#InvalidParameterValueException":
1694
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1695
- case "MissingParameterValueException":
1696
- case "com.amazonaws.glacier#MissingParameterValueException":
1697
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1698
- case "ResourceNotFoundException":
1699
- case "com.amazonaws.glacier#ResourceNotFoundException":
1700
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1701
- case "ServiceUnavailableException":
1702
- case "com.amazonaws.glacier#ServiceUnavailableException":
1703
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1704
- default:
1705
- const parsedBody = parsedOutput.body;
1706
- return throwDefaultError({
1707
- output,
1708
- parsedBody,
1709
- errorCode,
1710
- });
1711
- }
1712
- };
1713
845
  export const de_UploadArchiveCommand = async (output, context) => {
1714
846
  if (output.statusCode !== 201 && output.statusCode >= 300) {
1715
- return de_UploadArchiveCommandError(output, context);
847
+ return de_CommandError(output, context);
1716
848
  }
1717
849
  const contents = map({
1718
850
  $metadata: deserializeMetadata(output),
@@ -1723,40 +855,9 @@ export const de_UploadArchiveCommand = async (output, context) => {
1723
855
  await collectBody(output.body, context);
1724
856
  return contents;
1725
857
  };
1726
- const de_UploadArchiveCommandError = async (output, context) => {
1727
- const parsedOutput = {
1728
- ...output,
1729
- body: await parseErrorBody(output.body, context),
1730
- };
1731
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1732
- switch (errorCode) {
1733
- case "InvalidParameterValueException":
1734
- case "com.amazonaws.glacier#InvalidParameterValueException":
1735
- throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
1736
- case "MissingParameterValueException":
1737
- case "com.amazonaws.glacier#MissingParameterValueException":
1738
- throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1739
- case "RequestTimeoutException":
1740
- case "com.amazonaws.glacier#RequestTimeoutException":
1741
- throw await de_RequestTimeoutExceptionRes(parsedOutput, context);
1742
- case "ResourceNotFoundException":
1743
- case "com.amazonaws.glacier#ResourceNotFoundException":
1744
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1745
- case "ServiceUnavailableException":
1746
- case "com.amazonaws.glacier#ServiceUnavailableException":
1747
- throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
1748
- default:
1749
- const parsedBody = parsedOutput.body;
1750
- return throwDefaultError({
1751
- output,
1752
- parsedBody,
1753
- errorCode,
1754
- });
1755
- }
1756
- };
1757
858
  export const de_UploadMultipartPartCommand = async (output, context) => {
1758
859
  if (output.statusCode !== 204 && output.statusCode >= 300) {
1759
- return de_UploadMultipartPartCommandError(output, context);
860
+ return de_CommandError(output, context);
1760
861
  }
1761
862
  const contents = map({
1762
863
  $metadata: deserializeMetadata(output),
@@ -1765,7 +866,7 @@ export const de_UploadMultipartPartCommand = async (output, context) => {
1765
866
  await collectBody(output.body, context);
1766
867
  return contents;
1767
868
  };
1768
- const de_UploadMultipartPartCommandError = async (output, context) => {
869
+ const de_CommandError = async (output, context) => {
1769
870
  const parsedOutput = {
1770
871
  ...output,
1771
872
  body: await parseErrorBody(output.body, context),
@@ -1778,15 +879,24 @@ const de_UploadMultipartPartCommandError = async (output, context) => {
1778
879
  case "MissingParameterValueException":
1779
880
  case "com.amazonaws.glacier#MissingParameterValueException":
1780
881
  throw await de_MissingParameterValueExceptionRes(parsedOutput, context);
1781
- case "RequestTimeoutException":
1782
- case "com.amazonaws.glacier#RequestTimeoutException":
1783
- throw await de_RequestTimeoutExceptionRes(parsedOutput, context);
1784
882
  case "ResourceNotFoundException":
1785
883
  case "com.amazonaws.glacier#ResourceNotFoundException":
1786
884
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1787
885
  case "ServiceUnavailableException":
1788
886
  case "com.amazonaws.glacier#ServiceUnavailableException":
1789
887
  throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
888
+ case "LimitExceededException":
889
+ case "com.amazonaws.glacier#LimitExceededException":
890
+ throw await de_LimitExceededExceptionRes(parsedOutput, context);
891
+ case "InsufficientCapacityException":
892
+ case "com.amazonaws.glacier#InsufficientCapacityException":
893
+ throw await de_InsufficientCapacityExceptionRes(parsedOutput, context);
894
+ case "PolicyEnforcedException":
895
+ case "com.amazonaws.glacier#PolicyEnforcedException":
896
+ throw await de_PolicyEnforcedExceptionRes(parsedOutput, context);
897
+ case "RequestTimeoutException":
898
+ case "com.amazonaws.glacier#RequestTimeoutException":
899
+ throw await de_RequestTimeoutExceptionRes(parsedOutput, context);
1790
900
  default:
1791
901
  const parsedBody = parsedOutput.body;
1792
902
  return throwDefaultError({