@aws-sdk/client-amplify 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 +53 -1100
  2. package/dist-es/protocols/Aws_restJson1.js +66 -1113
  3. package/package.json +3 -3
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -546,7 +546,7 @@ export const se_UpdateWebhookCommand = async (input, context) => {
546
546
  };
547
547
  export const de_CreateAppCommand = async (output, context) => {
548
548
  if (output.statusCode !== 200 && output.statusCode >= 300) {
549
- return de_CreateAppCommandError(output, context);
549
+ return de_CommandError(output, context);
550
550
  }
551
551
  const contents = map({
552
552
  $metadata: deserializeMetadata(output),
@@ -558,40 +558,9 @@ export const de_CreateAppCommand = async (output, context) => {
558
558
  Object.assign(contents, doc);
559
559
  return contents;
560
560
  };
561
- const de_CreateAppCommandError = async (output, context) => {
562
- const parsedOutput = {
563
- ...output,
564
- body: await parseErrorBody(output.body, context),
565
- };
566
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
567
- switch (errorCode) {
568
- case "BadRequestException":
569
- case "com.amazonaws.amplify#BadRequestException":
570
- throw await de_BadRequestExceptionRes(parsedOutput, context);
571
- case "DependentServiceFailureException":
572
- case "com.amazonaws.amplify#DependentServiceFailureException":
573
- throw await de_DependentServiceFailureExceptionRes(parsedOutput, context);
574
- case "InternalFailureException":
575
- case "com.amazonaws.amplify#InternalFailureException":
576
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
577
- case "LimitExceededException":
578
- case "com.amazonaws.amplify#LimitExceededException":
579
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
580
- case "UnauthorizedException":
581
- case "com.amazonaws.amplify#UnauthorizedException":
582
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
583
- default:
584
- const parsedBody = parsedOutput.body;
585
- return throwDefaultError({
586
- output,
587
- parsedBody,
588
- errorCode,
589
- });
590
- }
591
- };
592
561
  export const de_CreateBackendEnvironmentCommand = async (output, context) => {
593
562
  if (output.statusCode !== 200 && output.statusCode >= 300) {
594
- return de_CreateBackendEnvironmentCommandError(output, context);
563
+ return de_CommandError(output, context);
595
564
  }
596
565
  const contents = map({
597
566
  $metadata: deserializeMetadata(output),
@@ -603,40 +572,9 @@ export const de_CreateBackendEnvironmentCommand = async (output, context) => {
603
572
  Object.assign(contents, doc);
604
573
  return contents;
605
574
  };
606
- const de_CreateBackendEnvironmentCommandError = async (output, context) => {
607
- const parsedOutput = {
608
- ...output,
609
- body: await parseErrorBody(output.body, context),
610
- };
611
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
612
- switch (errorCode) {
613
- case "BadRequestException":
614
- case "com.amazonaws.amplify#BadRequestException":
615
- throw await de_BadRequestExceptionRes(parsedOutput, context);
616
- case "InternalFailureException":
617
- case "com.amazonaws.amplify#InternalFailureException":
618
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
619
- case "LimitExceededException":
620
- case "com.amazonaws.amplify#LimitExceededException":
621
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
622
- case "NotFoundException":
623
- case "com.amazonaws.amplify#NotFoundException":
624
- throw await de_NotFoundExceptionRes(parsedOutput, context);
625
- case "UnauthorizedException":
626
- case "com.amazonaws.amplify#UnauthorizedException":
627
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
628
- default:
629
- const parsedBody = parsedOutput.body;
630
- return throwDefaultError({
631
- output,
632
- parsedBody,
633
- errorCode,
634
- });
635
- }
636
- };
637
575
  export const de_CreateBranchCommand = async (output, context) => {
638
576
  if (output.statusCode !== 200 && output.statusCode >= 300) {
639
- return de_CreateBranchCommandError(output, context);
577
+ return de_CommandError(output, context);
640
578
  }
641
579
  const contents = map({
642
580
  $metadata: deserializeMetadata(output),
@@ -648,43 +586,9 @@ export const de_CreateBranchCommand = async (output, context) => {
648
586
  Object.assign(contents, doc);
649
587
  return contents;
650
588
  };
651
- const de_CreateBranchCommandError = async (output, context) => {
652
- const parsedOutput = {
653
- ...output,
654
- body: await parseErrorBody(output.body, context),
655
- };
656
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
657
- switch (errorCode) {
658
- case "BadRequestException":
659
- case "com.amazonaws.amplify#BadRequestException":
660
- throw await de_BadRequestExceptionRes(parsedOutput, context);
661
- case "DependentServiceFailureException":
662
- case "com.amazonaws.amplify#DependentServiceFailureException":
663
- throw await de_DependentServiceFailureExceptionRes(parsedOutput, context);
664
- case "InternalFailureException":
665
- case "com.amazonaws.amplify#InternalFailureException":
666
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
667
- case "LimitExceededException":
668
- case "com.amazonaws.amplify#LimitExceededException":
669
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
670
- case "NotFoundException":
671
- case "com.amazonaws.amplify#NotFoundException":
672
- throw await de_NotFoundExceptionRes(parsedOutput, context);
673
- case "UnauthorizedException":
674
- case "com.amazonaws.amplify#UnauthorizedException":
675
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
676
- default:
677
- const parsedBody = parsedOutput.body;
678
- return throwDefaultError({
679
- output,
680
- parsedBody,
681
- errorCode,
682
- });
683
- }
684
- };
685
589
  export const de_CreateDeploymentCommand = async (output, context) => {
686
590
  if (output.statusCode !== 200 && output.statusCode >= 300) {
687
- return de_CreateDeploymentCommandError(output, context);
591
+ return de_CommandError(output, context);
688
592
  }
689
593
  const contents = map({
690
594
  $metadata: deserializeMetadata(output),
@@ -698,37 +602,9 @@ export const de_CreateDeploymentCommand = async (output, context) => {
698
602
  Object.assign(contents, doc);
699
603
  return contents;
700
604
  };
701
- const de_CreateDeploymentCommandError = async (output, context) => {
702
- const parsedOutput = {
703
- ...output,
704
- body: await parseErrorBody(output.body, context),
705
- };
706
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
707
- switch (errorCode) {
708
- case "BadRequestException":
709
- case "com.amazonaws.amplify#BadRequestException":
710
- throw await de_BadRequestExceptionRes(parsedOutput, context);
711
- case "InternalFailureException":
712
- case "com.amazonaws.amplify#InternalFailureException":
713
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
714
- case "LimitExceededException":
715
- case "com.amazonaws.amplify#LimitExceededException":
716
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
717
- case "UnauthorizedException":
718
- case "com.amazonaws.amplify#UnauthorizedException":
719
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
720
- default:
721
- const parsedBody = parsedOutput.body;
722
- return throwDefaultError({
723
- output,
724
- parsedBody,
725
- errorCode,
726
- });
727
- }
728
- };
729
605
  export const de_CreateDomainAssociationCommand = async (output, context) => {
730
606
  if (output.statusCode !== 200 && output.statusCode >= 300) {
731
- return de_CreateDomainAssociationCommandError(output, context);
607
+ return de_CommandError(output, context);
732
608
  }
733
609
  const contents = map({
734
610
  $metadata: deserializeMetadata(output),
@@ -740,43 +616,9 @@ export const de_CreateDomainAssociationCommand = async (output, context) => {
740
616
  Object.assign(contents, doc);
741
617
  return contents;
742
618
  };
743
- const de_CreateDomainAssociationCommandError = async (output, context) => {
744
- const parsedOutput = {
745
- ...output,
746
- body: await parseErrorBody(output.body, context),
747
- };
748
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
749
- switch (errorCode) {
750
- case "BadRequestException":
751
- case "com.amazonaws.amplify#BadRequestException":
752
- throw await de_BadRequestExceptionRes(parsedOutput, context);
753
- case "DependentServiceFailureException":
754
- case "com.amazonaws.amplify#DependentServiceFailureException":
755
- throw await de_DependentServiceFailureExceptionRes(parsedOutput, context);
756
- case "InternalFailureException":
757
- case "com.amazonaws.amplify#InternalFailureException":
758
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
759
- case "LimitExceededException":
760
- case "com.amazonaws.amplify#LimitExceededException":
761
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
762
- case "NotFoundException":
763
- case "com.amazonaws.amplify#NotFoundException":
764
- throw await de_NotFoundExceptionRes(parsedOutput, context);
765
- case "UnauthorizedException":
766
- case "com.amazonaws.amplify#UnauthorizedException":
767
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
768
- default:
769
- const parsedBody = parsedOutput.body;
770
- return throwDefaultError({
771
- output,
772
- parsedBody,
773
- errorCode,
774
- });
775
- }
776
- };
777
619
  export const de_CreateWebhookCommand = async (output, context) => {
778
620
  if (output.statusCode !== 200 && output.statusCode >= 300) {
779
- return de_CreateWebhookCommandError(output, context);
621
+ return de_CommandError(output, context);
780
622
  }
781
623
  const contents = map({
782
624
  $metadata: deserializeMetadata(output),
@@ -788,43 +630,9 @@ export const de_CreateWebhookCommand = async (output, context) => {
788
630
  Object.assign(contents, doc);
789
631
  return contents;
790
632
  };
791
- const de_CreateWebhookCommandError = async (output, context) => {
792
- const parsedOutput = {
793
- ...output,
794
- body: await parseErrorBody(output.body, context),
795
- };
796
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
797
- switch (errorCode) {
798
- case "BadRequestException":
799
- case "com.amazonaws.amplify#BadRequestException":
800
- throw await de_BadRequestExceptionRes(parsedOutput, context);
801
- case "DependentServiceFailureException":
802
- case "com.amazonaws.amplify#DependentServiceFailureException":
803
- throw await de_DependentServiceFailureExceptionRes(parsedOutput, context);
804
- case "InternalFailureException":
805
- case "com.amazonaws.amplify#InternalFailureException":
806
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
807
- case "LimitExceededException":
808
- case "com.amazonaws.amplify#LimitExceededException":
809
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
810
- case "NotFoundException":
811
- case "com.amazonaws.amplify#NotFoundException":
812
- throw await de_NotFoundExceptionRes(parsedOutput, context);
813
- case "UnauthorizedException":
814
- case "com.amazonaws.amplify#UnauthorizedException":
815
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
816
- default:
817
- const parsedBody = parsedOutput.body;
818
- return throwDefaultError({
819
- output,
820
- parsedBody,
821
- errorCode,
822
- });
823
- }
824
- };
825
633
  export const de_DeleteAppCommand = async (output, context) => {
826
634
  if (output.statusCode !== 200 && output.statusCode >= 300) {
827
- return de_DeleteAppCommandError(output, context);
635
+ return de_CommandError(output, context);
828
636
  }
829
637
  const contents = map({
830
638
  $metadata: deserializeMetadata(output),
@@ -836,40 +644,9 @@ export const de_DeleteAppCommand = async (output, context) => {
836
644
  Object.assign(contents, doc);
837
645
  return contents;
838
646
  };
839
- const de_DeleteAppCommandError = async (output, context) => {
840
- const parsedOutput = {
841
- ...output,
842
- body: await parseErrorBody(output.body, context),
843
- };
844
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
845
- switch (errorCode) {
846
- case "BadRequestException":
847
- case "com.amazonaws.amplify#BadRequestException":
848
- throw await de_BadRequestExceptionRes(parsedOutput, context);
849
- case "DependentServiceFailureException":
850
- case "com.amazonaws.amplify#DependentServiceFailureException":
851
- throw await de_DependentServiceFailureExceptionRes(parsedOutput, context);
852
- case "InternalFailureException":
853
- case "com.amazonaws.amplify#InternalFailureException":
854
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
855
- case "NotFoundException":
856
- case "com.amazonaws.amplify#NotFoundException":
857
- throw await de_NotFoundExceptionRes(parsedOutput, context);
858
- case "UnauthorizedException":
859
- case "com.amazonaws.amplify#UnauthorizedException":
860
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
861
- default:
862
- const parsedBody = parsedOutput.body;
863
- return throwDefaultError({
864
- output,
865
- parsedBody,
866
- errorCode,
867
- });
868
- }
869
- };
870
647
  export const de_DeleteBackendEnvironmentCommand = async (output, context) => {
871
648
  if (output.statusCode !== 200 && output.statusCode >= 300) {
872
- return de_DeleteBackendEnvironmentCommandError(output, context);
649
+ return de_CommandError(output, context);
873
650
  }
874
651
  const contents = map({
875
652
  $metadata: deserializeMetadata(output),
@@ -881,40 +658,9 @@ export const de_DeleteBackendEnvironmentCommand = async (output, context) => {
881
658
  Object.assign(contents, doc);
882
659
  return contents;
883
660
  };
884
- const de_DeleteBackendEnvironmentCommandError = async (output, context) => {
885
- const parsedOutput = {
886
- ...output,
887
- body: await parseErrorBody(output.body, context),
888
- };
889
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
890
- switch (errorCode) {
891
- case "BadRequestException":
892
- case "com.amazonaws.amplify#BadRequestException":
893
- throw await de_BadRequestExceptionRes(parsedOutput, context);
894
- case "DependentServiceFailureException":
895
- case "com.amazonaws.amplify#DependentServiceFailureException":
896
- throw await de_DependentServiceFailureExceptionRes(parsedOutput, context);
897
- case "InternalFailureException":
898
- case "com.amazonaws.amplify#InternalFailureException":
899
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
900
- case "NotFoundException":
901
- case "com.amazonaws.amplify#NotFoundException":
902
- throw await de_NotFoundExceptionRes(parsedOutput, context);
903
- case "UnauthorizedException":
904
- case "com.amazonaws.amplify#UnauthorizedException":
905
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
906
- default:
907
- const parsedBody = parsedOutput.body;
908
- return throwDefaultError({
909
- output,
910
- parsedBody,
911
- errorCode,
912
- });
913
- }
914
- };
915
661
  export const de_DeleteBranchCommand = async (output, context) => {
916
662
  if (output.statusCode !== 200 && output.statusCode >= 300) {
917
- return de_DeleteBranchCommandError(output, context);
663
+ return de_CommandError(output, context);
918
664
  }
919
665
  const contents = map({
920
666
  $metadata: deserializeMetadata(output),
@@ -926,40 +672,9 @@ export const de_DeleteBranchCommand = async (output, context) => {
926
672
  Object.assign(contents, doc);
927
673
  return contents;
928
674
  };
929
- const de_DeleteBranchCommandError = async (output, context) => {
930
- const parsedOutput = {
931
- ...output,
932
- body: await parseErrorBody(output.body, context),
933
- };
934
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
935
- switch (errorCode) {
936
- case "BadRequestException":
937
- case "com.amazonaws.amplify#BadRequestException":
938
- throw await de_BadRequestExceptionRes(parsedOutput, context);
939
- case "DependentServiceFailureException":
940
- case "com.amazonaws.amplify#DependentServiceFailureException":
941
- throw await de_DependentServiceFailureExceptionRes(parsedOutput, context);
942
- case "InternalFailureException":
943
- case "com.amazonaws.amplify#InternalFailureException":
944
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
945
- case "NotFoundException":
946
- case "com.amazonaws.amplify#NotFoundException":
947
- throw await de_NotFoundExceptionRes(parsedOutput, context);
948
- case "UnauthorizedException":
949
- case "com.amazonaws.amplify#UnauthorizedException":
950
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
951
- default:
952
- const parsedBody = parsedOutput.body;
953
- return throwDefaultError({
954
- output,
955
- parsedBody,
956
- errorCode,
957
- });
958
- }
959
- };
960
675
  export const de_DeleteDomainAssociationCommand = async (output, context) => {
961
676
  if (output.statusCode !== 200 && output.statusCode >= 300) {
962
- return de_DeleteDomainAssociationCommandError(output, context);
677
+ return de_CommandError(output, context);
963
678
  }
964
679
  const contents = map({
965
680
  $metadata: deserializeMetadata(output),
@@ -971,40 +686,9 @@ export const de_DeleteDomainAssociationCommand = async (output, context) => {
971
686
  Object.assign(contents, doc);
972
687
  return contents;
973
688
  };
974
- const de_DeleteDomainAssociationCommandError = async (output, context) => {
975
- const parsedOutput = {
976
- ...output,
977
- body: await parseErrorBody(output.body, context),
978
- };
979
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
980
- switch (errorCode) {
981
- case "BadRequestException":
982
- case "com.amazonaws.amplify#BadRequestException":
983
- throw await de_BadRequestExceptionRes(parsedOutput, context);
984
- case "DependentServiceFailureException":
985
- case "com.amazonaws.amplify#DependentServiceFailureException":
986
- throw await de_DependentServiceFailureExceptionRes(parsedOutput, context);
987
- case "InternalFailureException":
988
- case "com.amazonaws.amplify#InternalFailureException":
989
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
990
- case "NotFoundException":
991
- case "com.amazonaws.amplify#NotFoundException":
992
- throw await de_NotFoundExceptionRes(parsedOutput, context);
993
- case "UnauthorizedException":
994
- case "com.amazonaws.amplify#UnauthorizedException":
995
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
996
- default:
997
- const parsedBody = parsedOutput.body;
998
- return throwDefaultError({
999
- output,
1000
- parsedBody,
1001
- errorCode,
1002
- });
1003
- }
1004
- };
1005
689
  export const de_DeleteJobCommand = async (output, context) => {
1006
690
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1007
- return de_DeleteJobCommandError(output, context);
691
+ return de_CommandError(output, context);
1008
692
  }
1009
693
  const contents = map({
1010
694
  $metadata: deserializeMetadata(output),
@@ -1016,40 +700,9 @@ export const de_DeleteJobCommand = async (output, context) => {
1016
700
  Object.assign(contents, doc);
1017
701
  return contents;
1018
702
  };
1019
- const de_DeleteJobCommandError = async (output, context) => {
1020
- const parsedOutput = {
1021
- ...output,
1022
- body: await parseErrorBody(output.body, context),
1023
- };
1024
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1025
- switch (errorCode) {
1026
- case "BadRequestException":
1027
- case "com.amazonaws.amplify#BadRequestException":
1028
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1029
- case "InternalFailureException":
1030
- case "com.amazonaws.amplify#InternalFailureException":
1031
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1032
- case "LimitExceededException":
1033
- case "com.amazonaws.amplify#LimitExceededException":
1034
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1035
- case "NotFoundException":
1036
- case "com.amazonaws.amplify#NotFoundException":
1037
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1038
- case "UnauthorizedException":
1039
- case "com.amazonaws.amplify#UnauthorizedException":
1040
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1041
- default:
1042
- const parsedBody = parsedOutput.body;
1043
- return throwDefaultError({
1044
- output,
1045
- parsedBody,
1046
- errorCode,
1047
- });
1048
- }
1049
- };
1050
703
  export const de_DeleteWebhookCommand = async (output, context) => {
1051
704
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1052
- return de_DeleteWebhookCommandError(output, context);
705
+ return de_CommandError(output, context);
1053
706
  }
1054
707
  const contents = map({
1055
708
  $metadata: deserializeMetadata(output),
@@ -1061,40 +714,9 @@ export const de_DeleteWebhookCommand = async (output, context) => {
1061
714
  Object.assign(contents, doc);
1062
715
  return contents;
1063
716
  };
1064
- const de_DeleteWebhookCommandError = async (output, context) => {
1065
- const parsedOutput = {
1066
- ...output,
1067
- body: await parseErrorBody(output.body, context),
1068
- };
1069
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1070
- switch (errorCode) {
1071
- case "BadRequestException":
1072
- case "com.amazonaws.amplify#BadRequestException":
1073
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1074
- case "InternalFailureException":
1075
- case "com.amazonaws.amplify#InternalFailureException":
1076
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1077
- case "LimitExceededException":
1078
- case "com.amazonaws.amplify#LimitExceededException":
1079
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1080
- case "NotFoundException":
1081
- case "com.amazonaws.amplify#NotFoundException":
1082
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1083
- case "UnauthorizedException":
1084
- case "com.amazonaws.amplify#UnauthorizedException":
1085
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1086
- default:
1087
- const parsedBody = parsedOutput.body;
1088
- return throwDefaultError({
1089
- output,
1090
- parsedBody,
1091
- errorCode,
1092
- });
1093
- }
1094
- };
1095
717
  export const de_GenerateAccessLogsCommand = async (output, context) => {
1096
718
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1097
- return de_GenerateAccessLogsCommandError(output, context);
719
+ return de_CommandError(output, context);
1098
720
  }
1099
721
  const contents = map({
1100
722
  $metadata: deserializeMetadata(output),
@@ -1106,37 +728,9 @@ export const de_GenerateAccessLogsCommand = async (output, context) => {
1106
728
  Object.assign(contents, doc);
1107
729
  return contents;
1108
730
  };
1109
- const de_GenerateAccessLogsCommandError = async (output, context) => {
1110
- const parsedOutput = {
1111
- ...output,
1112
- body: await parseErrorBody(output.body, context),
1113
- };
1114
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1115
- switch (errorCode) {
1116
- case "BadRequestException":
1117
- case "com.amazonaws.amplify#BadRequestException":
1118
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1119
- case "InternalFailureException":
1120
- case "com.amazonaws.amplify#InternalFailureException":
1121
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1122
- case "NotFoundException":
1123
- case "com.amazonaws.amplify#NotFoundException":
1124
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1125
- case "UnauthorizedException":
1126
- case "com.amazonaws.amplify#UnauthorizedException":
1127
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1128
- default:
1129
- const parsedBody = parsedOutput.body;
1130
- return throwDefaultError({
1131
- output,
1132
- parsedBody,
1133
- errorCode,
1134
- });
1135
- }
1136
- };
1137
731
  export const de_GetAppCommand = async (output, context) => {
1138
732
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1139
- return de_GetAppCommandError(output, context);
733
+ return de_CommandError(output, context);
1140
734
  }
1141
735
  const contents = map({
1142
736
  $metadata: deserializeMetadata(output),
@@ -1148,37 +742,9 @@ export const de_GetAppCommand = async (output, context) => {
1148
742
  Object.assign(contents, doc);
1149
743
  return contents;
1150
744
  };
1151
- const de_GetAppCommandError = async (output, context) => {
1152
- const parsedOutput = {
1153
- ...output,
1154
- body: await parseErrorBody(output.body, context),
1155
- };
1156
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1157
- switch (errorCode) {
1158
- case "BadRequestException":
1159
- case "com.amazonaws.amplify#BadRequestException":
1160
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1161
- case "InternalFailureException":
1162
- case "com.amazonaws.amplify#InternalFailureException":
1163
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1164
- case "NotFoundException":
1165
- case "com.amazonaws.amplify#NotFoundException":
1166
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1167
- case "UnauthorizedException":
1168
- case "com.amazonaws.amplify#UnauthorizedException":
1169
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1170
- default:
1171
- const parsedBody = parsedOutput.body;
1172
- return throwDefaultError({
1173
- output,
1174
- parsedBody,
1175
- errorCode,
1176
- });
1177
- }
1178
- };
1179
745
  export const de_GetArtifactUrlCommand = async (output, context) => {
1180
746
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1181
- return de_GetArtifactUrlCommandError(output, context);
747
+ return de_CommandError(output, context);
1182
748
  }
1183
749
  const contents = map({
1184
750
  $metadata: deserializeMetadata(output),
@@ -1191,40 +757,9 @@ export const de_GetArtifactUrlCommand = async (output, context) => {
1191
757
  Object.assign(contents, doc);
1192
758
  return contents;
1193
759
  };
1194
- const de_GetArtifactUrlCommandError = async (output, context) => {
1195
- const parsedOutput = {
1196
- ...output,
1197
- body: await parseErrorBody(output.body, context),
1198
- };
1199
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1200
- switch (errorCode) {
1201
- case "BadRequestException":
1202
- case "com.amazonaws.amplify#BadRequestException":
1203
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1204
- case "InternalFailureException":
1205
- case "com.amazonaws.amplify#InternalFailureException":
1206
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1207
- case "LimitExceededException":
1208
- case "com.amazonaws.amplify#LimitExceededException":
1209
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1210
- case "NotFoundException":
1211
- case "com.amazonaws.amplify#NotFoundException":
1212
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1213
- case "UnauthorizedException":
1214
- case "com.amazonaws.amplify#UnauthorizedException":
1215
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1216
- default:
1217
- const parsedBody = parsedOutput.body;
1218
- return throwDefaultError({
1219
- output,
1220
- parsedBody,
1221
- errorCode,
1222
- });
1223
- }
1224
- };
1225
760
  export const de_GetBackendEnvironmentCommand = async (output, context) => {
1226
761
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1227
- return de_GetBackendEnvironmentCommandError(output, context);
762
+ return de_CommandError(output, context);
1228
763
  }
1229
764
  const contents = map({
1230
765
  $metadata: deserializeMetadata(output),
@@ -1236,37 +771,9 @@ export const de_GetBackendEnvironmentCommand = async (output, context) => {
1236
771
  Object.assign(contents, doc);
1237
772
  return contents;
1238
773
  };
1239
- const de_GetBackendEnvironmentCommandError = 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 "BadRequestException":
1247
- case "com.amazonaws.amplify#BadRequestException":
1248
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1249
- case "InternalFailureException":
1250
- case "com.amazonaws.amplify#InternalFailureException":
1251
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1252
- case "NotFoundException":
1253
- case "com.amazonaws.amplify#NotFoundException":
1254
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1255
- case "UnauthorizedException":
1256
- case "com.amazonaws.amplify#UnauthorizedException":
1257
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1258
- default:
1259
- const parsedBody = parsedOutput.body;
1260
- return throwDefaultError({
1261
- output,
1262
- parsedBody,
1263
- errorCode,
1264
- });
1265
- }
1266
- };
1267
774
  export const de_GetBranchCommand = async (output, context) => {
1268
775
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1269
- return de_GetBranchCommandError(output, context);
776
+ return de_CommandError(output, context);
1270
777
  }
1271
778
  const contents = map({
1272
779
  $metadata: deserializeMetadata(output),
@@ -1278,37 +785,9 @@ export const de_GetBranchCommand = async (output, context) => {
1278
785
  Object.assign(contents, doc);
1279
786
  return contents;
1280
787
  };
1281
- const de_GetBranchCommandError = async (output, context) => {
1282
- const parsedOutput = {
1283
- ...output,
1284
- body: await parseErrorBody(output.body, context),
1285
- };
1286
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1287
- switch (errorCode) {
1288
- case "BadRequestException":
1289
- case "com.amazonaws.amplify#BadRequestException":
1290
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1291
- case "InternalFailureException":
1292
- case "com.amazonaws.amplify#InternalFailureException":
1293
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1294
- case "NotFoundException":
1295
- case "com.amazonaws.amplify#NotFoundException":
1296
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1297
- case "UnauthorizedException":
1298
- case "com.amazonaws.amplify#UnauthorizedException":
1299
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1300
- default:
1301
- const parsedBody = parsedOutput.body;
1302
- return throwDefaultError({
1303
- output,
1304
- parsedBody,
1305
- errorCode,
1306
- });
1307
- }
1308
- };
1309
788
  export const de_GetDomainAssociationCommand = async (output, context) => {
1310
789
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1311
- return de_GetDomainAssociationCommandError(output, context);
790
+ return de_CommandError(output, context);
1312
791
  }
1313
792
  const contents = map({
1314
793
  $metadata: deserializeMetadata(output),
@@ -1320,37 +799,9 @@ export const de_GetDomainAssociationCommand = async (output, context) => {
1320
799
  Object.assign(contents, doc);
1321
800
  return contents;
1322
801
  };
1323
- const de_GetDomainAssociationCommandError = async (output, context) => {
1324
- const parsedOutput = {
1325
- ...output,
1326
- body: await parseErrorBody(output.body, context),
1327
- };
1328
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1329
- switch (errorCode) {
1330
- case "BadRequestException":
1331
- case "com.amazonaws.amplify#BadRequestException":
1332
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1333
- case "InternalFailureException":
1334
- case "com.amazonaws.amplify#InternalFailureException":
1335
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1336
- case "NotFoundException":
1337
- case "com.amazonaws.amplify#NotFoundException":
1338
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1339
- case "UnauthorizedException":
1340
- case "com.amazonaws.amplify#UnauthorizedException":
1341
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1342
- default:
1343
- const parsedBody = parsedOutput.body;
1344
- return throwDefaultError({
1345
- output,
1346
- parsedBody,
1347
- errorCode,
1348
- });
1349
- }
1350
- };
1351
802
  export const de_GetJobCommand = async (output, context) => {
1352
803
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1353
- return de_GetJobCommandError(output, context);
804
+ return de_CommandError(output, context);
1354
805
  }
1355
806
  const contents = map({
1356
807
  $metadata: deserializeMetadata(output),
@@ -1362,40 +813,9 @@ export const de_GetJobCommand = async (output, context) => {
1362
813
  Object.assign(contents, doc);
1363
814
  return contents;
1364
815
  };
1365
- const de_GetJobCommandError = async (output, context) => {
1366
- const parsedOutput = {
1367
- ...output,
1368
- body: await parseErrorBody(output.body, context),
1369
- };
1370
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1371
- switch (errorCode) {
1372
- case "BadRequestException":
1373
- case "com.amazonaws.amplify#BadRequestException":
1374
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1375
- case "InternalFailureException":
1376
- case "com.amazonaws.amplify#InternalFailureException":
1377
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1378
- case "LimitExceededException":
1379
- case "com.amazonaws.amplify#LimitExceededException":
1380
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1381
- case "NotFoundException":
1382
- case "com.amazonaws.amplify#NotFoundException":
1383
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1384
- case "UnauthorizedException":
1385
- case "com.amazonaws.amplify#UnauthorizedException":
1386
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1387
- default:
1388
- const parsedBody = parsedOutput.body;
1389
- return throwDefaultError({
1390
- output,
1391
- parsedBody,
1392
- errorCode,
1393
- });
1394
- }
1395
- };
1396
816
  export const de_GetWebhookCommand = async (output, context) => {
1397
817
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1398
- return de_GetWebhookCommandError(output, context);
818
+ return de_CommandError(output, context);
1399
819
  }
1400
820
  const contents = map({
1401
821
  $metadata: deserializeMetadata(output),
@@ -1407,40 +827,9 @@ export const de_GetWebhookCommand = async (output, context) => {
1407
827
  Object.assign(contents, doc);
1408
828
  return contents;
1409
829
  };
1410
- const de_GetWebhookCommandError = async (output, context) => {
1411
- const parsedOutput = {
1412
- ...output,
1413
- body: await parseErrorBody(output.body, context),
1414
- };
1415
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1416
- switch (errorCode) {
1417
- case "BadRequestException":
1418
- case "com.amazonaws.amplify#BadRequestException":
1419
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1420
- case "InternalFailureException":
1421
- case "com.amazonaws.amplify#InternalFailureException":
1422
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1423
- case "LimitExceededException":
1424
- case "com.amazonaws.amplify#LimitExceededException":
1425
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1426
- case "NotFoundException":
1427
- case "com.amazonaws.amplify#NotFoundException":
1428
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1429
- case "UnauthorizedException":
1430
- case "com.amazonaws.amplify#UnauthorizedException":
1431
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1432
- default:
1433
- const parsedBody = parsedOutput.body;
1434
- return throwDefaultError({
1435
- output,
1436
- parsedBody,
1437
- errorCode,
1438
- });
1439
- }
1440
- };
1441
830
  export const de_ListAppsCommand = async (output, context) => {
1442
831
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1443
- return de_ListAppsCommandError(output, context);
832
+ return de_CommandError(output, context);
1444
833
  }
1445
834
  const contents = map({
1446
835
  $metadata: deserializeMetadata(output),
@@ -1453,34 +842,9 @@ export const de_ListAppsCommand = async (output, context) => {
1453
842
  Object.assign(contents, doc);
1454
843
  return contents;
1455
844
  };
1456
- const de_ListAppsCommandError = async (output, context) => {
1457
- const parsedOutput = {
1458
- ...output,
1459
- body: await parseErrorBody(output.body, context),
1460
- };
1461
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1462
- switch (errorCode) {
1463
- case "BadRequestException":
1464
- case "com.amazonaws.amplify#BadRequestException":
1465
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1466
- case "InternalFailureException":
1467
- case "com.amazonaws.amplify#InternalFailureException":
1468
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1469
- case "UnauthorizedException":
1470
- case "com.amazonaws.amplify#UnauthorizedException":
1471
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1472
- default:
1473
- const parsedBody = parsedOutput.body;
1474
- return throwDefaultError({
1475
- output,
1476
- parsedBody,
1477
- errorCode,
1478
- });
1479
- }
1480
- };
1481
845
  export const de_ListArtifactsCommand = async (output, context) => {
1482
846
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1483
- return de_ListArtifactsCommandError(output, context);
847
+ return de_CommandError(output, context);
1484
848
  }
1485
849
  const contents = map({
1486
850
  $metadata: deserializeMetadata(output),
@@ -1493,37 +857,9 @@ export const de_ListArtifactsCommand = async (output, context) => {
1493
857
  Object.assign(contents, doc);
1494
858
  return contents;
1495
859
  };
1496
- const de_ListArtifactsCommandError = async (output, context) => {
1497
- const parsedOutput = {
1498
- ...output,
1499
- body: await parseErrorBody(output.body, context),
1500
- };
1501
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1502
- switch (errorCode) {
1503
- case "BadRequestException":
1504
- case "com.amazonaws.amplify#BadRequestException":
1505
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1506
- case "InternalFailureException":
1507
- case "com.amazonaws.amplify#InternalFailureException":
1508
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1509
- case "LimitExceededException":
1510
- case "com.amazonaws.amplify#LimitExceededException":
1511
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1512
- case "UnauthorizedException":
1513
- case "com.amazonaws.amplify#UnauthorizedException":
1514
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1515
- default:
1516
- const parsedBody = parsedOutput.body;
1517
- return throwDefaultError({
1518
- output,
1519
- parsedBody,
1520
- errorCode,
1521
- });
1522
- }
1523
- };
1524
860
  export const de_ListBackendEnvironmentsCommand = async (output, context) => {
1525
861
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1526
- return de_ListBackendEnvironmentsCommandError(output, context);
862
+ return de_CommandError(output, context);
1527
863
  }
1528
864
  const contents = map({
1529
865
  $metadata: deserializeMetadata(output),
@@ -1536,34 +872,9 @@ export const de_ListBackendEnvironmentsCommand = async (output, context) => {
1536
872
  Object.assign(contents, doc);
1537
873
  return contents;
1538
874
  };
1539
- const de_ListBackendEnvironmentsCommandError = async (output, context) => {
1540
- const parsedOutput = {
1541
- ...output,
1542
- body: await parseErrorBody(output.body, context),
1543
- };
1544
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1545
- switch (errorCode) {
1546
- case "BadRequestException":
1547
- case "com.amazonaws.amplify#BadRequestException":
1548
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1549
- case "InternalFailureException":
1550
- case "com.amazonaws.amplify#InternalFailureException":
1551
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1552
- case "UnauthorizedException":
1553
- case "com.amazonaws.amplify#UnauthorizedException":
1554
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1555
- default:
1556
- const parsedBody = parsedOutput.body;
1557
- return throwDefaultError({
1558
- output,
1559
- parsedBody,
1560
- errorCode,
1561
- });
1562
- }
1563
- };
1564
875
  export const de_ListBranchesCommand = async (output, context) => {
1565
876
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1566
- return de_ListBranchesCommandError(output, context);
877
+ return de_CommandError(output, context);
1567
878
  }
1568
879
  const contents = map({
1569
880
  $metadata: deserializeMetadata(output),
@@ -1576,34 +887,9 @@ export const de_ListBranchesCommand = async (output, context) => {
1576
887
  Object.assign(contents, doc);
1577
888
  return contents;
1578
889
  };
1579
- const de_ListBranchesCommandError = async (output, context) => {
1580
- const parsedOutput = {
1581
- ...output,
1582
- body: await parseErrorBody(output.body, context),
1583
- };
1584
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1585
- switch (errorCode) {
1586
- case "BadRequestException":
1587
- case "com.amazonaws.amplify#BadRequestException":
1588
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1589
- case "InternalFailureException":
1590
- case "com.amazonaws.amplify#InternalFailureException":
1591
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1592
- case "UnauthorizedException":
1593
- case "com.amazonaws.amplify#UnauthorizedException":
1594
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1595
- default:
1596
- const parsedBody = parsedOutput.body;
1597
- return throwDefaultError({
1598
- output,
1599
- parsedBody,
1600
- errorCode,
1601
- });
1602
- }
1603
- };
1604
890
  export const de_ListDomainAssociationsCommand = async (output, context) => {
1605
891
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1606
- return de_ListDomainAssociationsCommandError(output, context);
892
+ return de_CommandError(output, context);
1607
893
  }
1608
894
  const contents = map({
1609
895
  $metadata: deserializeMetadata(output),
@@ -1616,34 +902,9 @@ export const de_ListDomainAssociationsCommand = async (output, context) => {
1616
902
  Object.assign(contents, doc);
1617
903
  return contents;
1618
904
  };
1619
- const de_ListDomainAssociationsCommandError = async (output, context) => {
1620
- const parsedOutput = {
1621
- ...output,
1622
- body: await parseErrorBody(output.body, context),
1623
- };
1624
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1625
- switch (errorCode) {
1626
- case "BadRequestException":
1627
- case "com.amazonaws.amplify#BadRequestException":
1628
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1629
- case "InternalFailureException":
1630
- case "com.amazonaws.amplify#InternalFailureException":
1631
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1632
- case "UnauthorizedException":
1633
- case "com.amazonaws.amplify#UnauthorizedException":
1634
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1635
- default:
1636
- const parsedBody = parsedOutput.body;
1637
- return throwDefaultError({
1638
- output,
1639
- parsedBody,
1640
- errorCode,
1641
- });
1642
- }
1643
- };
1644
905
  export const de_ListJobsCommand = async (output, context) => {
1645
906
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1646
- return de_ListJobsCommandError(output, context);
907
+ return de_CommandError(output, context);
1647
908
  }
1648
909
  const contents = map({
1649
910
  $metadata: deserializeMetadata(output),
@@ -1656,119 +917,38 @@ export const de_ListJobsCommand = async (output, context) => {
1656
917
  Object.assign(contents, doc);
1657
918
  return contents;
1658
919
  };
1659
- const de_ListJobsCommandError = async (output, context) => {
1660
- const parsedOutput = {
1661
- ...output,
1662
- body: await parseErrorBody(output.body, context),
1663
- };
1664
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1665
- switch (errorCode) {
1666
- case "BadRequestException":
1667
- case "com.amazonaws.amplify#BadRequestException":
1668
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1669
- case "InternalFailureException":
1670
- case "com.amazonaws.amplify#InternalFailureException":
1671
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1672
- case "LimitExceededException":
1673
- case "com.amazonaws.amplify#LimitExceededException":
1674
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1675
- case "UnauthorizedException":
1676
- case "com.amazonaws.amplify#UnauthorizedException":
1677
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1678
- default:
1679
- const parsedBody = parsedOutput.body;
1680
- return throwDefaultError({
1681
- output,
1682
- parsedBody,
1683
- errorCode,
1684
- });
1685
- }
1686
- };
1687
920
  export const de_ListTagsForResourceCommand = async (output, context) => {
1688
921
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1689
- return de_ListTagsForResourceCommandError(output, context);
1690
- }
1691
- const contents = map({
1692
- $metadata: deserializeMetadata(output),
1693
- });
1694
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1695
- const doc = take(data, {
1696
- tags: _json,
1697
- });
1698
- Object.assign(contents, doc);
1699
- return contents;
1700
- };
1701
- const de_ListTagsForResourceCommandError = async (output, context) => {
1702
- const parsedOutput = {
1703
- ...output,
1704
- body: await parseErrorBody(output.body, context),
1705
- };
1706
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1707
- switch (errorCode) {
1708
- case "BadRequestException":
1709
- case "com.amazonaws.amplify#BadRequestException":
1710
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1711
- case "InternalFailureException":
1712
- case "com.amazonaws.amplify#InternalFailureException":
1713
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1714
- case "ResourceNotFoundException":
1715
- case "com.amazonaws.amplify#ResourceNotFoundException":
1716
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1717
- default:
1718
- const parsedBody = parsedOutput.body;
1719
- return throwDefaultError({
1720
- output,
1721
- parsedBody,
1722
- errorCode,
1723
- });
1724
- }
1725
- };
1726
- export const de_ListWebhooksCommand = async (output, context) => {
1727
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1728
- return de_ListWebhooksCommandError(output, context);
922
+ return de_CommandError(output, context);
1729
923
  }
1730
924
  const contents = map({
1731
925
  $metadata: deserializeMetadata(output),
1732
926
  });
1733
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1734
- const doc = take(data, {
1735
- nextToken: __expectString,
1736
- webhooks: (_) => de_Webhooks(_, context),
1737
- });
1738
- Object.assign(contents, doc);
1739
- return contents;
1740
- };
1741
- const de_ListWebhooksCommandError = async (output, context) => {
1742
- const parsedOutput = {
1743
- ...output,
1744
- body: await parseErrorBody(output.body, context),
1745
- };
1746
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1747
- switch (errorCode) {
1748
- case "BadRequestException":
1749
- case "com.amazonaws.amplify#BadRequestException":
1750
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1751
- case "InternalFailureException":
1752
- case "com.amazonaws.amplify#InternalFailureException":
1753
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1754
- case "LimitExceededException":
1755
- case "com.amazonaws.amplify#LimitExceededException":
1756
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1757
- case "UnauthorizedException":
1758
- case "com.amazonaws.amplify#UnauthorizedException":
1759
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1760
- default:
1761
- const parsedBody = parsedOutput.body;
1762
- return throwDefaultError({
1763
- output,
1764
- parsedBody,
1765
- errorCode,
1766
- });
927
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
928
+ const doc = take(data, {
929
+ tags: _json,
930
+ });
931
+ Object.assign(contents, doc);
932
+ return contents;
933
+ };
934
+ export const de_ListWebhooksCommand = async (output, context) => {
935
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
936
+ return de_CommandError(output, context);
1767
937
  }
938
+ const contents = map({
939
+ $metadata: deserializeMetadata(output),
940
+ });
941
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
942
+ const doc = take(data, {
943
+ nextToken: __expectString,
944
+ webhooks: (_) => de_Webhooks(_, context),
945
+ });
946
+ Object.assign(contents, doc);
947
+ return contents;
1768
948
  };
1769
949
  export const de_StartDeploymentCommand = async (output, context) => {
1770
950
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1771
- return de_StartDeploymentCommandError(output, context);
951
+ return de_CommandError(output, context);
1772
952
  }
1773
953
  const contents = map({
1774
954
  $metadata: deserializeMetadata(output),
@@ -1780,40 +960,9 @@ export const de_StartDeploymentCommand = async (output, context) => {
1780
960
  Object.assign(contents, doc);
1781
961
  return contents;
1782
962
  };
1783
- const de_StartDeploymentCommandError = async (output, context) => {
1784
- const parsedOutput = {
1785
- ...output,
1786
- body: await parseErrorBody(output.body, context),
1787
- };
1788
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1789
- switch (errorCode) {
1790
- case "BadRequestException":
1791
- case "com.amazonaws.amplify#BadRequestException":
1792
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1793
- case "InternalFailureException":
1794
- case "com.amazonaws.amplify#InternalFailureException":
1795
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1796
- case "LimitExceededException":
1797
- case "com.amazonaws.amplify#LimitExceededException":
1798
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1799
- case "NotFoundException":
1800
- case "com.amazonaws.amplify#NotFoundException":
1801
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1802
- case "UnauthorizedException":
1803
- case "com.amazonaws.amplify#UnauthorizedException":
1804
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1805
- default:
1806
- const parsedBody = parsedOutput.body;
1807
- return throwDefaultError({
1808
- output,
1809
- parsedBody,
1810
- errorCode,
1811
- });
1812
- }
1813
- };
1814
963
  export const de_StartJobCommand = async (output, context) => {
1815
964
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1816
- return de_StartJobCommandError(output, context);
965
+ return de_CommandError(output, context);
1817
966
  }
1818
967
  const contents = map({
1819
968
  $metadata: deserializeMetadata(output),
@@ -1825,40 +974,9 @@ export const de_StartJobCommand = async (output, context) => {
1825
974
  Object.assign(contents, doc);
1826
975
  return contents;
1827
976
  };
1828
- const de_StartJobCommandError = async (output, context) => {
1829
- const parsedOutput = {
1830
- ...output,
1831
- body: await parseErrorBody(output.body, context),
1832
- };
1833
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1834
- switch (errorCode) {
1835
- case "BadRequestException":
1836
- case "com.amazonaws.amplify#BadRequestException":
1837
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1838
- case "InternalFailureException":
1839
- case "com.amazonaws.amplify#InternalFailureException":
1840
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1841
- case "LimitExceededException":
1842
- case "com.amazonaws.amplify#LimitExceededException":
1843
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1844
- case "NotFoundException":
1845
- case "com.amazonaws.amplify#NotFoundException":
1846
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1847
- case "UnauthorizedException":
1848
- case "com.amazonaws.amplify#UnauthorizedException":
1849
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1850
- default:
1851
- const parsedBody = parsedOutput.body;
1852
- return throwDefaultError({
1853
- output,
1854
- parsedBody,
1855
- errorCode,
1856
- });
1857
- }
1858
- };
1859
977
  export const de_StopJobCommand = async (output, context) => {
1860
978
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1861
- return de_StopJobCommandError(output, context);
979
+ return de_CommandError(output, context);
1862
980
  }
1863
981
  const contents = map({
1864
982
  $metadata: deserializeMetadata(output),
@@ -1870,40 +988,9 @@ export const de_StopJobCommand = async (output, context) => {
1870
988
  Object.assign(contents, doc);
1871
989
  return contents;
1872
990
  };
1873
- const de_StopJobCommandError = async (output, context) => {
1874
- const parsedOutput = {
1875
- ...output,
1876
- body: await parseErrorBody(output.body, context),
1877
- };
1878
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1879
- switch (errorCode) {
1880
- case "BadRequestException":
1881
- case "com.amazonaws.amplify#BadRequestException":
1882
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1883
- case "InternalFailureException":
1884
- case "com.amazonaws.amplify#InternalFailureException":
1885
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1886
- case "LimitExceededException":
1887
- case "com.amazonaws.amplify#LimitExceededException":
1888
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1889
- case "NotFoundException":
1890
- case "com.amazonaws.amplify#NotFoundException":
1891
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1892
- case "UnauthorizedException":
1893
- case "com.amazonaws.amplify#UnauthorizedException":
1894
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1895
- default:
1896
- const parsedBody = parsedOutput.body;
1897
- return throwDefaultError({
1898
- output,
1899
- parsedBody,
1900
- errorCode,
1901
- });
1902
- }
1903
- };
1904
991
  export const de_TagResourceCommand = async (output, context) => {
1905
992
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1906
- return de_TagResourceCommandError(output, context);
993
+ return de_CommandError(output, context);
1907
994
  }
1908
995
  const contents = map({
1909
996
  $metadata: deserializeMetadata(output),
@@ -1911,34 +998,9 @@ export const de_TagResourceCommand = async (output, context) => {
1911
998
  await collectBody(output.body, context);
1912
999
  return contents;
1913
1000
  };
1914
- const de_TagResourceCommandError = async (output, context) => {
1915
- const parsedOutput = {
1916
- ...output,
1917
- body: await parseErrorBody(output.body, context),
1918
- };
1919
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1920
- switch (errorCode) {
1921
- case "BadRequestException":
1922
- case "com.amazonaws.amplify#BadRequestException":
1923
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1924
- case "InternalFailureException":
1925
- case "com.amazonaws.amplify#InternalFailureException":
1926
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1927
- case "ResourceNotFoundException":
1928
- case "com.amazonaws.amplify#ResourceNotFoundException":
1929
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1930
- default:
1931
- const parsedBody = parsedOutput.body;
1932
- return throwDefaultError({
1933
- output,
1934
- parsedBody,
1935
- errorCode,
1936
- });
1937
- }
1938
- };
1939
1001
  export const de_UntagResourceCommand = async (output, context) => {
1940
1002
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1941
- return de_UntagResourceCommandError(output, context);
1003
+ return de_CommandError(output, context);
1942
1004
  }
1943
1005
  const contents = map({
1944
1006
  $metadata: deserializeMetadata(output),
@@ -1946,34 +1008,9 @@ export const de_UntagResourceCommand = async (output, context) => {
1946
1008
  await collectBody(output.body, context);
1947
1009
  return contents;
1948
1010
  };
1949
- const de_UntagResourceCommandError = async (output, context) => {
1950
- const parsedOutput = {
1951
- ...output,
1952
- body: await parseErrorBody(output.body, context),
1953
- };
1954
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1955
- switch (errorCode) {
1956
- case "BadRequestException":
1957
- case "com.amazonaws.amplify#BadRequestException":
1958
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1959
- case "InternalFailureException":
1960
- case "com.amazonaws.amplify#InternalFailureException":
1961
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
1962
- case "ResourceNotFoundException":
1963
- case "com.amazonaws.amplify#ResourceNotFoundException":
1964
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1965
- default:
1966
- const parsedBody = parsedOutput.body;
1967
- return throwDefaultError({
1968
- output,
1969
- parsedBody,
1970
- errorCode,
1971
- });
1972
- }
1973
- };
1974
1011
  export const de_UpdateAppCommand = async (output, context) => {
1975
1012
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1976
- return de_UpdateAppCommandError(output, context);
1013
+ return de_CommandError(output, context);
1977
1014
  }
1978
1015
  const contents = map({
1979
1016
  $metadata: deserializeMetadata(output),
@@ -1985,37 +1022,9 @@ export const de_UpdateAppCommand = async (output, context) => {
1985
1022
  Object.assign(contents, doc);
1986
1023
  return contents;
1987
1024
  };
1988
- const de_UpdateAppCommandError = async (output, context) => {
1989
- const parsedOutput = {
1990
- ...output,
1991
- body: await parseErrorBody(output.body, context),
1992
- };
1993
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1994
- switch (errorCode) {
1995
- case "BadRequestException":
1996
- case "com.amazonaws.amplify#BadRequestException":
1997
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1998
- case "InternalFailureException":
1999
- case "com.amazonaws.amplify#InternalFailureException":
2000
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2001
- case "NotFoundException":
2002
- case "com.amazonaws.amplify#NotFoundException":
2003
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2004
- case "UnauthorizedException":
2005
- case "com.amazonaws.amplify#UnauthorizedException":
2006
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2007
- default:
2008
- const parsedBody = parsedOutput.body;
2009
- return throwDefaultError({
2010
- output,
2011
- parsedBody,
2012
- errorCode,
2013
- });
2014
- }
2015
- };
2016
1025
  export const de_UpdateBranchCommand = async (output, context) => {
2017
1026
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2018
- return de_UpdateBranchCommandError(output, context);
1027
+ return de_CommandError(output, context);
2019
1028
  }
2020
1029
  const contents = map({
2021
1030
  $metadata: deserializeMetadata(output),
@@ -2027,40 +1036,9 @@ export const de_UpdateBranchCommand = async (output, context) => {
2027
1036
  Object.assign(contents, doc);
2028
1037
  return contents;
2029
1038
  };
2030
- const de_UpdateBranchCommandError = async (output, context) => {
2031
- const parsedOutput = {
2032
- ...output,
2033
- body: await parseErrorBody(output.body, context),
2034
- };
2035
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2036
- switch (errorCode) {
2037
- case "BadRequestException":
2038
- case "com.amazonaws.amplify#BadRequestException":
2039
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2040
- case "DependentServiceFailureException":
2041
- case "com.amazonaws.amplify#DependentServiceFailureException":
2042
- throw await de_DependentServiceFailureExceptionRes(parsedOutput, context);
2043
- case "InternalFailureException":
2044
- case "com.amazonaws.amplify#InternalFailureException":
2045
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2046
- case "NotFoundException":
2047
- case "com.amazonaws.amplify#NotFoundException":
2048
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2049
- case "UnauthorizedException":
2050
- case "com.amazonaws.amplify#UnauthorizedException":
2051
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2052
- default:
2053
- const parsedBody = parsedOutput.body;
2054
- return throwDefaultError({
2055
- output,
2056
- parsedBody,
2057
- errorCode,
2058
- });
2059
- }
2060
- };
2061
1039
  export const de_UpdateDomainAssociationCommand = async (output, context) => {
2062
1040
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2063
- return de_UpdateDomainAssociationCommandError(output, context);
1041
+ return de_CommandError(output, context);
2064
1042
  }
2065
1043
  const contents = map({
2066
1044
  $metadata: deserializeMetadata(output),
@@ -2072,40 +1050,9 @@ export const de_UpdateDomainAssociationCommand = async (output, context) => {
2072
1050
  Object.assign(contents, doc);
2073
1051
  return contents;
2074
1052
  };
2075
- const de_UpdateDomainAssociationCommandError = async (output, context) => {
2076
- const parsedOutput = {
2077
- ...output,
2078
- body: await parseErrorBody(output.body, context),
2079
- };
2080
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2081
- switch (errorCode) {
2082
- case "BadRequestException":
2083
- case "com.amazonaws.amplify#BadRequestException":
2084
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2085
- case "DependentServiceFailureException":
2086
- case "com.amazonaws.amplify#DependentServiceFailureException":
2087
- throw await de_DependentServiceFailureExceptionRes(parsedOutput, context);
2088
- case "InternalFailureException":
2089
- case "com.amazonaws.amplify#InternalFailureException":
2090
- throw await de_InternalFailureExceptionRes(parsedOutput, context);
2091
- case "NotFoundException":
2092
- case "com.amazonaws.amplify#NotFoundException":
2093
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2094
- case "UnauthorizedException":
2095
- case "com.amazonaws.amplify#UnauthorizedException":
2096
- throw await de_UnauthorizedExceptionRes(parsedOutput, context);
2097
- default:
2098
- const parsedBody = parsedOutput.body;
2099
- return throwDefaultError({
2100
- output,
2101
- parsedBody,
2102
- errorCode,
2103
- });
2104
- }
2105
- };
2106
1053
  export const de_UpdateWebhookCommand = async (output, context) => {
2107
1054
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2108
- return de_UpdateWebhookCommandError(output, context);
1055
+ return de_CommandError(output, context);
2109
1056
  }
2110
1057
  const contents = map({
2111
1058
  $metadata: deserializeMetadata(output),
@@ -2117,7 +1064,7 @@ export const de_UpdateWebhookCommand = async (output, context) => {
2117
1064
  Object.assign(contents, doc);
2118
1065
  return contents;
2119
1066
  };
2120
- const de_UpdateWebhookCommandError = async (output, context) => {
1067
+ const de_CommandError = async (output, context) => {
2121
1068
  const parsedOutput = {
2122
1069
  ...output,
2123
1070
  body: await parseErrorBody(output.body, context),
@@ -2133,12 +1080,18 @@ const de_UpdateWebhookCommandError = async (output, context) => {
2133
1080
  case "InternalFailureException":
2134
1081
  case "com.amazonaws.amplify#InternalFailureException":
2135
1082
  throw await de_InternalFailureExceptionRes(parsedOutput, context);
2136
- case "NotFoundException":
2137
- case "com.amazonaws.amplify#NotFoundException":
2138
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1083
+ case "LimitExceededException":
1084
+ case "com.amazonaws.amplify#LimitExceededException":
1085
+ throw await de_LimitExceededExceptionRes(parsedOutput, context);
2139
1086
  case "UnauthorizedException":
2140
1087
  case "com.amazonaws.amplify#UnauthorizedException":
2141
1088
  throw await de_UnauthorizedExceptionRes(parsedOutput, context);
1089
+ case "NotFoundException":
1090
+ case "com.amazonaws.amplify#NotFoundException":
1091
+ throw await de_NotFoundExceptionRes(parsedOutput, context);
1092
+ case "ResourceNotFoundException":
1093
+ case "com.amazonaws.amplify#ResourceNotFoundException":
1094
+ throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2142
1095
  default:
2143
1096
  const parsedBody = parsedOutput.body;
2144
1097
  return throwDefaultError({