@aws-sdk/client-elastic-beanstalk 3.52.0 → 3.53.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 (16) hide show
  1. package/CHANGELOG.md +11 -0
  2. package/dist-cjs/index.js +3 -0
  3. package/dist-cjs/models/ElasticBeanstalkServiceException.js +11 -0
  4. package/dist-cjs/models/models_0.js +251 -3
  5. package/dist-cjs/protocols/Aws_query.js +312 -955
  6. package/dist-es/index.js +1 -0
  7. package/dist-es/models/ElasticBeanstalkServiceException.js +12 -0
  8. package/dist-es/models/models_0.js +230 -1
  9. package/dist-es/protocols/Aws_query.js +698 -1008
  10. package/dist-types/index.d.ts +1 -0
  11. package/dist-types/models/ElasticBeanstalkServiceException.d.ts +10 -0
  12. package/dist-types/models/models_0.d.ts +97 -96
  13. package/dist-types/ts3.4/index.d.ts +1 -0
  14. package/dist-types/ts3.4/models/ElasticBeanstalkServiceException.d.ts +6 -0
  15. package/dist-types/ts3.4/models/models_0.d.ts +78 -77
  16. package/package.json +26 -26
package/dist-cjs/protocols/Aws_query.js CHANGED
@@ -6,6 +6,8 @@ const protocol_http_1 = require("@aws-sdk/protocol-http");
6
6
  const smithy_client_1 = require("@aws-sdk/smithy-client");
7
7
  const entities_1 = require("entities");
8
8
  const fast_xml_parser_1 = require("fast-xml-parser");
9
+ const ElasticBeanstalkServiceException_1 = require("../models/ElasticBeanstalkServiceException");
10
+ const models_0_1 = require("../models/models_0");
9
11
  const serializeAws_queryAbortEnvironmentUpdateCommand = async (input, context) => {
10
12
  const headers = {
11
13
  "content-type": "application/x-www-form-urlencoded",
@@ -633,27 +635,16 @@ const deserializeAws_queryAbortEnvironmentUpdateCommandError = async (output, co
633
635
  switch (errorCode) {
634
636
  case "InsufficientPrivilegesException":
635
637
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
636
- response = {
637
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
638
- name: errorCode,
639
- $metadata: deserializeMetadata(output),
640
- };
641
- break;
638
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
642
639
  default:
643
640
  const parsedBody = parsedOutput.body;
644
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
645
- response = {
646
- ...parsedBody.Error,
647
- name: `${errorCode}`,
648
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
641
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
642
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
649
643
  $fault: "client",
650
644
  $metadata: deserializeMetadata(output),
651
- };
645
+ });
646
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
652
647
  }
653
- const message = response.message || response.Message || errorCode;
654
- response.message = message;
655
- delete response.Message;
656
- return Promise.reject(Object.assign(new Error(message), response));
657
648
  };
658
649
  const deserializeAws_queryApplyEnvironmentManagedActionCommand = async (output, context) => {
659
650
  if (output.statusCode >= 300) {
@@ -680,35 +671,19 @@ const deserializeAws_queryApplyEnvironmentManagedActionCommandError = async (out
680
671
  switch (errorCode) {
681
672
  case "ElasticBeanstalkServiceException":
682
673
  case "com.amazonaws.elasticbeanstalk#ElasticBeanstalkServiceException":
683
- response = {
684
- ...(await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context)),
685
- name: errorCode,
686
- $metadata: deserializeMetadata(output),
687
- };
688
- break;
674
+ throw await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context);
689
675
  case "ManagedActionInvalidStateException":
690
676
  case "com.amazonaws.elasticbeanstalk#ManagedActionInvalidStateException":
691
- response = {
692
- ...(await deserializeAws_queryManagedActionInvalidStateExceptionResponse(parsedOutput, context)),
693
- name: errorCode,
694
- $metadata: deserializeMetadata(output),
695
- };
696
- break;
677
+ throw await deserializeAws_queryManagedActionInvalidStateExceptionResponse(parsedOutput, context);
697
678
  default:
698
679
  const parsedBody = parsedOutput.body;
699
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
700
- response = {
701
- ...parsedBody.Error,
702
- name: `${errorCode}`,
703
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
680
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
681
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
704
682
  $fault: "client",
705
683
  $metadata: deserializeMetadata(output),
706
- };
684
+ });
685
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
707
686
  }
708
- const message = response.message || response.Message || errorCode;
709
- response.message = message;
710
- delete response.Message;
711
- return Promise.reject(Object.assign(new Error(message), response));
712
687
  };
713
688
  const deserializeAws_queryAssociateEnvironmentOperationsRoleCommand = async (output, context) => {
714
689
  if (output.statusCode >= 300) {
@@ -732,27 +707,16 @@ const deserializeAws_queryAssociateEnvironmentOperationsRoleCommandError = async
732
707
  switch (errorCode) {
733
708
  case "InsufficientPrivilegesException":
734
709
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
735
- response = {
736
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
737
- name: errorCode,
738
- $metadata: deserializeMetadata(output),
739
- };
740
- break;
710
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
741
711
  default:
742
712
  const parsedBody = parsedOutput.body;
743
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
744
- response = {
745
- ...parsedBody.Error,
746
- name: `${errorCode}`,
747
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
713
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
714
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
748
715
  $fault: "client",
749
716
  $metadata: deserializeMetadata(output),
750
- };
717
+ });
718
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
751
719
  }
752
- const message = response.message || response.Message || errorCode;
753
- response.message = message;
754
- delete response.Message;
755
- return Promise.reject(Object.assign(new Error(message), response));
756
720
  };
757
721
  const deserializeAws_queryCheckDNSAvailabilityCommand = async (output, context) => {
758
722
  if (output.statusCode >= 300) {
@@ -779,19 +743,13 @@ const deserializeAws_queryCheckDNSAvailabilityCommandError = async (output, cont
779
743
  switch (errorCode) {
780
744
  default:
781
745
  const parsedBody = parsedOutput.body;
782
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
783
- response = {
784
- ...parsedBody.Error,
785
- name: `${errorCode}`,
786
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
746
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
747
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
787
748
  $fault: "client",
788
749
  $metadata: deserializeMetadata(output),
789
- };
750
+ });
751
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
790
752
  }
791
- const message = response.message || response.Message || errorCode;
792
- response.message = message;
793
- delete response.Message;
794
- return Promise.reject(Object.assign(new Error(message), response));
795
753
  };
796
754
  const deserializeAws_queryComposeEnvironmentsCommand = async (output, context) => {
797
755
  if (output.statusCode >= 300) {
@@ -818,35 +776,19 @@ const deserializeAws_queryComposeEnvironmentsCommandError = async (output, conte
818
776
  switch (errorCode) {
819
777
  case "InsufficientPrivilegesException":
820
778
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
821
- response = {
822
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
823
- name: errorCode,
824
- $metadata: deserializeMetadata(output),
825
- };
826
- break;
779
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
827
780
  case "TooManyEnvironmentsException":
828
781
  case "com.amazonaws.elasticbeanstalk#TooManyEnvironmentsException":
829
- response = {
830
- ...(await deserializeAws_queryTooManyEnvironmentsExceptionResponse(parsedOutput, context)),
831
- name: errorCode,
832
- $metadata: deserializeMetadata(output),
833
- };
834
- break;
782
+ throw await deserializeAws_queryTooManyEnvironmentsExceptionResponse(parsedOutput, context);
835
783
  default:
836
784
  const parsedBody = parsedOutput.body;
837
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
838
- response = {
839
- ...parsedBody.Error,
840
- name: `${errorCode}`,
841
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
785
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
786
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
842
787
  $fault: "client",
843
788
  $metadata: deserializeMetadata(output),
844
- };
789
+ });
790
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
845
791
  }
846
- const message = response.message || response.Message || errorCode;
847
- response.message = message;
848
- delete response.Message;
849
- return Promise.reject(Object.assign(new Error(message), response));
850
792
  };
851
793
  const deserializeAws_queryCreateApplicationCommand = async (output, context) => {
852
794
  if (output.statusCode >= 300) {
@@ -873,27 +815,16 @@ const deserializeAws_queryCreateApplicationCommandError = async (output, context
873
815
  switch (errorCode) {
874
816
  case "TooManyApplicationsException":
875
817
  case "com.amazonaws.elasticbeanstalk#TooManyApplicationsException":
876
- response = {
877
- ...(await deserializeAws_queryTooManyApplicationsExceptionResponse(parsedOutput, context)),
878
- name: errorCode,
879
- $metadata: deserializeMetadata(output),
880
- };
881
- break;
818
+ throw await deserializeAws_queryTooManyApplicationsExceptionResponse(parsedOutput, context);
882
819
  default:
883
820
  const parsedBody = parsedOutput.body;
884
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
885
- response = {
886
- ...parsedBody.Error,
887
- name: `${errorCode}`,
888
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
821
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
822
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
889
823
  $fault: "client",
890
824
  $metadata: deserializeMetadata(output),
891
- };
825
+ });
826
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
892
827
  }
893
- const message = response.message || response.Message || errorCode;
894
- response.message = message;
895
- delete response.Message;
896
- return Promise.reject(Object.assign(new Error(message), response));
897
828
  };
898
829
  const deserializeAws_queryCreateApplicationVersionCommand = async (output, context) => {
899
830
  if (output.statusCode >= 300) {
@@ -920,59 +851,28 @@ const deserializeAws_queryCreateApplicationVersionCommandError = async (output,
920
851
  switch (errorCode) {
921
852
  case "CodeBuildNotInServiceRegionException":
922
853
  case "com.amazonaws.elasticbeanstalk#CodeBuildNotInServiceRegionException":
923
- response = {
924
- ...(await deserializeAws_queryCodeBuildNotInServiceRegionExceptionResponse(parsedOutput, context)),
925
- name: errorCode,
926
- $metadata: deserializeMetadata(output),
927
- };
928
- break;
854
+ throw await deserializeAws_queryCodeBuildNotInServiceRegionExceptionResponse(parsedOutput, context);
929
855
  case "InsufficientPrivilegesException":
930
856
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
931
- response = {
932
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
933
- name: errorCode,
934
- $metadata: deserializeMetadata(output),
935
- };
936
- break;
857
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
937
858
  case "S3LocationNotInServiceRegionException":
938
859
  case "com.amazonaws.elasticbeanstalk#S3LocationNotInServiceRegionException":
939
- response = {
940
- ...(await deserializeAws_queryS3LocationNotInServiceRegionExceptionResponse(parsedOutput, context)),
941
- name: errorCode,
942
- $metadata: deserializeMetadata(output),
943
- };
944
- break;
860
+ throw await deserializeAws_queryS3LocationNotInServiceRegionExceptionResponse(parsedOutput, context);
945
861
  case "TooManyApplicationsException":
946
862
  case "com.amazonaws.elasticbeanstalk#TooManyApplicationsException":
947
- response = {
948
- ...(await deserializeAws_queryTooManyApplicationsExceptionResponse(parsedOutput, context)),
949
- name: errorCode,
950
- $metadata: deserializeMetadata(output),
951
- };
952
- break;
863
+ throw await deserializeAws_queryTooManyApplicationsExceptionResponse(parsedOutput, context);
953
864
  case "TooManyApplicationVersionsException":
954
865
  case "com.amazonaws.elasticbeanstalk#TooManyApplicationVersionsException":
955
- response = {
956
- ...(await deserializeAws_queryTooManyApplicationVersionsExceptionResponse(parsedOutput, context)),
957
- name: errorCode,
958
- $metadata: deserializeMetadata(output),
959
- };
960
- break;
866
+ throw await deserializeAws_queryTooManyApplicationVersionsExceptionResponse(parsedOutput, context);
961
867
  default:
962
868
  const parsedBody = parsedOutput.body;
963
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
964
- response = {
965
- ...parsedBody.Error,
966
- name: `${errorCode}`,
967
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
869
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
870
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
968
871
  $fault: "client",
969
872
  $metadata: deserializeMetadata(output),
970
- };
873
+ });
874
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
971
875
  }
972
- const message = response.message || response.Message || errorCode;
973
- response.message = message;
974
- delete response.Message;
975
- return Promise.reject(Object.assign(new Error(message), response));
976
876
  };
977
877
  const deserializeAws_queryCreateConfigurationTemplateCommand = async (output, context) => {
978
878
  if (output.statusCode >= 300) {
@@ -999,43 +899,22 @@ const deserializeAws_queryCreateConfigurationTemplateCommandError = async (outpu
999
899
  switch (errorCode) {
1000
900
  case "InsufficientPrivilegesException":
1001
901
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
1002
- response = {
1003
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
1004
- name: errorCode,
1005
- $metadata: deserializeMetadata(output),
1006
- };
1007
- break;
902
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
1008
903
  case "TooManyBucketsException":
1009
904
  case "com.amazonaws.elasticbeanstalk#TooManyBucketsException":
1010
- response = {
1011
- ...(await deserializeAws_queryTooManyBucketsExceptionResponse(parsedOutput, context)),
1012
- name: errorCode,
1013
- $metadata: deserializeMetadata(output),
1014
- };
1015
- break;
905
+ throw await deserializeAws_queryTooManyBucketsExceptionResponse(parsedOutput, context);
1016
906
  case "TooManyConfigurationTemplatesException":
1017
907
  case "com.amazonaws.elasticbeanstalk#TooManyConfigurationTemplatesException":
1018
- response = {
1019
- ...(await deserializeAws_queryTooManyConfigurationTemplatesExceptionResponse(parsedOutput, context)),
1020
- name: errorCode,
1021
- $metadata: deserializeMetadata(output),
1022
- };
1023
- break;
908
+ throw await deserializeAws_queryTooManyConfigurationTemplatesExceptionResponse(parsedOutput, context);
1024
909
  default:
1025
910
  const parsedBody = parsedOutput.body;
1026
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1027
- response = {
1028
- ...parsedBody.Error,
1029
- name: `${errorCode}`,
1030
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
911
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
912
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1031
913
  $fault: "client",
1032
914
  $metadata: deserializeMetadata(output),
1033
- };
915
+ });
916
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1034
917
  }
1035
- const message = response.message || response.Message || errorCode;
1036
- response.message = message;
1037
- delete response.Message;
1038
- return Promise.reject(Object.assign(new Error(message), response));
1039
918
  };
1040
919
  const deserializeAws_queryCreateEnvironmentCommand = async (output, context) => {
1041
920
  if (output.statusCode >= 300) {
@@ -1062,35 +941,19 @@ const deserializeAws_queryCreateEnvironmentCommandError = async (output, context
1062
941
  switch (errorCode) {
1063
942
  case "InsufficientPrivilegesException":
1064
943
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
1065
- response = {
1066
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
1067
- name: errorCode,
1068
- $metadata: deserializeMetadata(output),
1069
- };
1070
- break;
944
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
1071
945
  case "TooManyEnvironmentsException":
1072
946
  case "com.amazonaws.elasticbeanstalk#TooManyEnvironmentsException":
1073
- response = {
1074
- ...(await deserializeAws_queryTooManyEnvironmentsExceptionResponse(parsedOutput, context)),
1075
- name: errorCode,
1076
- $metadata: deserializeMetadata(output),
1077
- };
1078
- break;
947
+ throw await deserializeAws_queryTooManyEnvironmentsExceptionResponse(parsedOutput, context);
1079
948
  default:
1080
949
  const parsedBody = parsedOutput.body;
1081
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1082
- response = {
1083
- ...parsedBody.Error,
1084
- name: `${errorCode}`,
1085
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
950
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
951
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1086
952
  $fault: "client",
1087
953
  $metadata: deserializeMetadata(output),
1088
- };
954
+ });
955
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1089
956
  }
1090
- const message = response.message || response.Message || errorCode;
1091
- response.message = message;
1092
- delete response.Message;
1093
- return Promise.reject(Object.assign(new Error(message), response));
1094
957
  };
1095
958
  const deserializeAws_queryCreatePlatformVersionCommand = async (output, context) => {
1096
959
  if (output.statusCode >= 300) {
@@ -1117,43 +980,22 @@ const deserializeAws_queryCreatePlatformVersionCommandError = async (output, con
1117
980
  switch (errorCode) {
1118
981
  case "ElasticBeanstalkServiceException":
1119
982
  case "com.amazonaws.elasticbeanstalk#ElasticBeanstalkServiceException":
1120
- response = {
1121
- ...(await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context)),
1122
- name: errorCode,
1123
- $metadata: deserializeMetadata(output),
1124
- };
1125
- break;
983
+ throw await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context);
1126
984
  case "InsufficientPrivilegesException":
1127
985
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
1128
- response = {
1129
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
1130
- name: errorCode,
1131
- $metadata: deserializeMetadata(output),
1132
- };
1133
- break;
986
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
1134
987
  case "TooManyPlatformsException":
1135
988
  case "com.amazonaws.elasticbeanstalk#TooManyPlatformsException":
1136
- response = {
1137
- ...(await deserializeAws_queryTooManyPlatformsExceptionResponse(parsedOutput, context)),
1138
- name: errorCode,
1139
- $metadata: deserializeMetadata(output),
1140
- };
1141
- break;
989
+ throw await deserializeAws_queryTooManyPlatformsExceptionResponse(parsedOutput, context);
1142
990
  default:
1143
991
  const parsedBody = parsedOutput.body;
1144
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1145
- response = {
1146
- ...parsedBody.Error,
1147
- name: `${errorCode}`,
1148
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
992
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
993
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1149
994
  $fault: "client",
1150
995
  $metadata: deserializeMetadata(output),
1151
- };
996
+ });
997
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1152
998
  }
1153
- const message = response.message || response.Message || errorCode;
1154
- response.message = message;
1155
- delete response.Message;
1156
- return Promise.reject(Object.assign(new Error(message), response));
1157
999
  };
1158
1000
  const deserializeAws_queryCreateStorageLocationCommand = async (output, context) => {
1159
1001
  if (output.statusCode >= 300) {
@@ -1180,43 +1022,22 @@ const deserializeAws_queryCreateStorageLocationCommandError = async (output, con
1180
1022
  switch (errorCode) {
1181
1023
  case "InsufficientPrivilegesException":
1182
1024
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
1183
- response = {
1184
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
1185
- name: errorCode,
1186
- $metadata: deserializeMetadata(output),
1187
- };
1188
- break;
1025
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
1189
1026
  case "S3SubscriptionRequiredException":
1190
1027
  case "com.amazonaws.elasticbeanstalk#S3SubscriptionRequiredException":
1191
- response = {
1192
- ...(await deserializeAws_queryS3SubscriptionRequiredExceptionResponse(parsedOutput, context)),
1193
- name: errorCode,
1194
- $metadata: deserializeMetadata(output),
1195
- };
1196
- break;
1028
+ throw await deserializeAws_queryS3SubscriptionRequiredExceptionResponse(parsedOutput, context);
1197
1029
  case "TooManyBucketsException":
1198
1030
  case "com.amazonaws.elasticbeanstalk#TooManyBucketsException":
1199
- response = {
1200
- ...(await deserializeAws_queryTooManyBucketsExceptionResponse(parsedOutput, context)),
1201
- name: errorCode,
1202
- $metadata: deserializeMetadata(output),
1203
- };
1204
- break;
1031
+ throw await deserializeAws_queryTooManyBucketsExceptionResponse(parsedOutput, context);
1205
1032
  default:
1206
1033
  const parsedBody = parsedOutput.body;
1207
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1208
- response = {
1209
- ...parsedBody.Error,
1210
- name: `${errorCode}`,
1211
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1034
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1035
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1212
1036
  $fault: "client",
1213
1037
  $metadata: deserializeMetadata(output),
1214
- };
1038
+ });
1039
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1215
1040
  }
1216
- const message = response.message || response.Message || errorCode;
1217
- response.message = message;
1218
- delete response.Message;
1219
- return Promise.reject(Object.assign(new Error(message), response));
1220
1041
  };
1221
1042
  const deserializeAws_queryDeleteApplicationCommand = async (output, context) => {
1222
1043
  if (output.statusCode >= 300) {
@@ -1240,27 +1061,16 @@ const deserializeAws_queryDeleteApplicationCommandError = async (output, context
1240
1061
  switch (errorCode) {
1241
1062
  case "OperationInProgressException":
1242
1063
  case "com.amazonaws.elasticbeanstalk#OperationInProgressException":
1243
- response = {
1244
- ...(await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)),
1245
- name: errorCode,
1246
- $metadata: deserializeMetadata(output),
1247
- };
1248
- break;
1064
+ throw await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context);
1249
1065
  default:
1250
1066
  const parsedBody = parsedOutput.body;
1251
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1252
- response = {
1253
- ...parsedBody.Error,
1254
- name: `${errorCode}`,
1255
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1067
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1068
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1256
1069
  $fault: "client",
1257
1070
  $metadata: deserializeMetadata(output),
1258
- };
1071
+ });
1072
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1259
1073
  }
1260
- const message = response.message || response.Message || errorCode;
1261
- response.message = message;
1262
- delete response.Message;
1263
- return Promise.reject(Object.assign(new Error(message), response));
1264
1074
  };
1265
1075
  const deserializeAws_queryDeleteApplicationVersionCommand = async (output, context) => {
1266
1076
  if (output.statusCode >= 300) {
@@ -1284,51 +1094,25 @@ const deserializeAws_queryDeleteApplicationVersionCommandError = async (output,
1284
1094
  switch (errorCode) {
1285
1095
  case "InsufficientPrivilegesException":
1286
1096
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
1287
- response = {
1288
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
1289
- name: errorCode,
1290
- $metadata: deserializeMetadata(output),
1291
- };
1292
- break;
1097
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
1293
1098
  case "OperationInProgressException":
1294
1099
  case "com.amazonaws.elasticbeanstalk#OperationInProgressException":
1295
- response = {
1296
- ...(await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)),
1297
- name: errorCode,
1298
- $metadata: deserializeMetadata(output),
1299
- };
1300
- break;
1100
+ throw await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context);
1301
1101
  case "S3LocationNotInServiceRegionException":
1302
1102
  case "com.amazonaws.elasticbeanstalk#S3LocationNotInServiceRegionException":
1303
- response = {
1304
- ...(await deserializeAws_queryS3LocationNotInServiceRegionExceptionResponse(parsedOutput, context)),
1305
- name: errorCode,
1306
- $metadata: deserializeMetadata(output),
1307
- };
1308
- break;
1103
+ throw await deserializeAws_queryS3LocationNotInServiceRegionExceptionResponse(parsedOutput, context);
1309
1104
  case "SourceBundleDeletionException":
1310
1105
  case "com.amazonaws.elasticbeanstalk#SourceBundleDeletionException":
1311
- response = {
1312
- ...(await deserializeAws_querySourceBundleDeletionExceptionResponse(parsedOutput, context)),
1313
- name: errorCode,
1314
- $metadata: deserializeMetadata(output),
1315
- };
1316
- break;
1106
+ throw await deserializeAws_querySourceBundleDeletionExceptionResponse(parsedOutput, context);
1317
1107
  default:
1318
1108
  const parsedBody = parsedOutput.body;
1319
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1320
- response = {
1321
- ...parsedBody.Error,
1322
- name: `${errorCode}`,
1323
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1109
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1110
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1324
1111
  $fault: "client",
1325
1112
  $metadata: deserializeMetadata(output),
1326
- };
1113
+ });
1114
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1327
1115
  }
1328
- const message = response.message || response.Message || errorCode;
1329
- response.message = message;
1330
- delete response.Message;
1331
- return Promise.reject(Object.assign(new Error(message), response));
1332
1116
  };
1333
1117
  const deserializeAws_queryDeleteConfigurationTemplateCommand = async (output, context) => {
1334
1118
  if (output.statusCode >= 300) {
@@ -1352,27 +1136,16 @@ const deserializeAws_queryDeleteConfigurationTemplateCommandError = async (outpu
1352
1136
  switch (errorCode) {
1353
1137
  case "OperationInProgressException":
1354
1138
  case "com.amazonaws.elasticbeanstalk#OperationInProgressException":
1355
- response = {
1356
- ...(await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)),
1357
- name: errorCode,
1358
- $metadata: deserializeMetadata(output),
1359
- };
1360
- break;
1139
+ throw await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context);
1361
1140
  default:
1362
1141
  const parsedBody = parsedOutput.body;
1363
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1364
- response = {
1365
- ...parsedBody.Error,
1366
- name: `${errorCode}`,
1367
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1142
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1143
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1368
1144
  $fault: "client",
1369
1145
  $metadata: deserializeMetadata(output),
1370
- };
1146
+ });
1147
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1371
1148
  }
1372
- const message = response.message || response.Message || errorCode;
1373
- response.message = message;
1374
- delete response.Message;
1375
- return Promise.reject(Object.assign(new Error(message), response));
1376
1149
  };
1377
1150
  const deserializeAws_queryDeleteEnvironmentConfigurationCommand = async (output, context) => {
1378
1151
  if (output.statusCode >= 300) {
@@ -1396,19 +1169,13 @@ const deserializeAws_queryDeleteEnvironmentConfigurationCommandError = async (ou
1396
1169
  switch (errorCode) {
1397
1170
  default:
1398
1171
  const parsedBody = parsedOutput.body;
1399
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1400
- response = {
1401
- ...parsedBody.Error,
1402
- name: `${errorCode}`,
1403
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1172
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1173
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1404
1174
  $fault: "client",
1405
1175
  $metadata: deserializeMetadata(output),
1406
- };
1176
+ });
1177
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1407
1178
  }
1408
- const message = response.message || response.Message || errorCode;
1409
- response.message = message;
1410
- delete response.Message;
1411
- return Promise.reject(Object.assign(new Error(message), response));
1412
1179
  };
1413
1180
  const deserializeAws_queryDeletePlatformVersionCommand = async (output, context) => {
1414
1181
  if (output.statusCode >= 300) {
@@ -1435,51 +1202,25 @@ const deserializeAws_queryDeletePlatformVersionCommandError = async (output, con
1435
1202
  switch (errorCode) {
1436
1203
  case "ElasticBeanstalkServiceException":
1437
1204
  case "com.amazonaws.elasticbeanstalk#ElasticBeanstalkServiceException":
1438
- response = {
1439
- ...(await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context)),
1440
- name: errorCode,
1441
- $metadata: deserializeMetadata(output),
1442
- };
1443
- break;
1205
+ throw await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context);
1444
1206
  case "InsufficientPrivilegesException":
1445
1207
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
1446
- response = {
1447
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
1448
- name: errorCode,
1449
- $metadata: deserializeMetadata(output),
1450
- };
1451
- break;
1208
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
1452
1209
  case "OperationInProgressException":
1453
1210
  case "com.amazonaws.elasticbeanstalk#OperationInProgressException":
1454
- response = {
1455
- ...(await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)),
1456
- name: errorCode,
1457
- $metadata: deserializeMetadata(output),
1458
- };
1459
- break;
1211
+ throw await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context);
1460
1212
  case "PlatformVersionStillReferencedException":
1461
1213
  case "com.amazonaws.elasticbeanstalk#PlatformVersionStillReferencedException":
1462
- response = {
1463
- ...(await deserializeAws_queryPlatformVersionStillReferencedExceptionResponse(parsedOutput, context)),
1464
- name: errorCode,
1465
- $metadata: deserializeMetadata(output),
1466
- };
1467
- break;
1214
+ throw await deserializeAws_queryPlatformVersionStillReferencedExceptionResponse(parsedOutput, context);
1468
1215
  default:
1469
1216
  const parsedBody = parsedOutput.body;
1470
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1471
- response = {
1472
- ...parsedBody.Error,
1473
- name: `${errorCode}`,
1474
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1217
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1218
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1475
1219
  $fault: "client",
1476
1220
  $metadata: deserializeMetadata(output),
1477
- };
1221
+ });
1222
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1478
1223
  }
1479
- const message = response.message || response.Message || errorCode;
1480
- response.message = message;
1481
- delete response.Message;
1482
- return Promise.reject(Object.assign(new Error(message), response));
1483
1224
  };
1484
1225
  const deserializeAws_queryDescribeAccountAttributesCommand = async (output, context) => {
1485
1226
  if (output.statusCode >= 300) {
@@ -1506,27 +1247,16 @@ const deserializeAws_queryDescribeAccountAttributesCommandError = async (output,
1506
1247
  switch (errorCode) {
1507
1248
  case "InsufficientPrivilegesException":
1508
1249
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
1509
- response = {
1510
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
1511
- name: errorCode,
1512
- $metadata: deserializeMetadata(output),
1513
- };
1514
- break;
1250
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
1515
1251
  default:
1516
1252
  const parsedBody = parsedOutput.body;
1517
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1518
- response = {
1519
- ...parsedBody.Error,
1520
- name: `${errorCode}`,
1521
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1253
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1254
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1522
1255
  $fault: "client",
1523
1256
  $metadata: deserializeMetadata(output),
1524
- };
1257
+ });
1258
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1525
1259
  }
1526
- const message = response.message || response.Message || errorCode;
1527
- response.message = message;
1528
- delete response.Message;
1529
- return Promise.reject(Object.assign(new Error(message), response));
1530
1260
  };
1531
1261
  const deserializeAws_queryDescribeApplicationsCommand = async (output, context) => {
1532
1262
  if (output.statusCode >= 300) {
@@ -1553,19 +1283,13 @@ const deserializeAws_queryDescribeApplicationsCommandError = async (output, cont
1553
1283
  switch (errorCode) {
1554
1284
  default:
1555
1285
  const parsedBody = parsedOutput.body;
1556
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1557
- response = {
1558
- ...parsedBody.Error,
1559
- name: `${errorCode}`,
1560
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1286
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1287
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1561
1288
  $fault: "client",
1562
1289
  $metadata: deserializeMetadata(output),
1563
- };
1290
+ });
1291
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1564
1292
  }
1565
- const message = response.message || response.Message || errorCode;
1566
- response.message = message;
1567
- delete response.Message;
1568
- return Promise.reject(Object.assign(new Error(message), response));
1569
1293
  };
1570
1294
  const deserializeAws_queryDescribeApplicationVersionsCommand = async (output, context) => {
1571
1295
  if (output.statusCode >= 300) {
@@ -1592,19 +1316,13 @@ const deserializeAws_queryDescribeApplicationVersionsCommandError = async (outpu
1592
1316
  switch (errorCode) {
1593
1317
  default:
1594
1318
  const parsedBody = parsedOutput.body;
1595
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1596
- response = {
1597
- ...parsedBody.Error,
1598
- name: `${errorCode}`,
1599
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1319
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1320
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1600
1321
  $fault: "client",
1601
1322
  $metadata: deserializeMetadata(output),
1602
- };
1323
+ });
1324
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1603
1325
  }
1604
- const message = response.message || response.Message || errorCode;
1605
- response.message = message;
1606
- delete response.Message;
1607
- return Promise.reject(Object.assign(new Error(message), response));
1608
1326
  };
1609
1327
  const deserializeAws_queryDescribeConfigurationOptionsCommand = async (output, context) => {
1610
1328
  if (output.statusCode >= 300) {
@@ -1631,27 +1349,16 @@ const deserializeAws_queryDescribeConfigurationOptionsCommandError = async (outp
1631
1349
  switch (errorCode) {
1632
1350
  case "TooManyBucketsException":
1633
1351
  case "com.amazonaws.elasticbeanstalk#TooManyBucketsException":
1634
- response = {
1635
- ...(await deserializeAws_queryTooManyBucketsExceptionResponse(parsedOutput, context)),
1636
- name: errorCode,
1637
- $metadata: deserializeMetadata(output),
1638
- };
1639
- break;
1352
+ throw await deserializeAws_queryTooManyBucketsExceptionResponse(parsedOutput, context);
1640
1353
  default:
1641
1354
  const parsedBody = parsedOutput.body;
1642
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1643
- response = {
1644
- ...parsedBody.Error,
1645
- name: `${errorCode}`,
1646
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1355
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1356
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1647
1357
  $fault: "client",
1648
1358
  $metadata: deserializeMetadata(output),
1649
- };
1359
+ });
1360
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1650
1361
  }
1651
- const message = response.message || response.Message || errorCode;
1652
- response.message = message;
1653
- delete response.Message;
1654
- return Promise.reject(Object.assign(new Error(message), response));
1655
1362
  };
1656
1363
  const deserializeAws_queryDescribeConfigurationSettingsCommand = async (output, context) => {
1657
1364
  if (output.statusCode >= 300) {
@@ -1678,27 +1385,16 @@ const deserializeAws_queryDescribeConfigurationSettingsCommandError = async (out
1678
1385
  switch (errorCode) {
1679
1386
  case "TooManyBucketsException":
1680
1387
  case "com.amazonaws.elasticbeanstalk#TooManyBucketsException":
1681
- response = {
1682
- ...(await deserializeAws_queryTooManyBucketsExceptionResponse(parsedOutput, context)),
1683
- name: errorCode,
1684
- $metadata: deserializeMetadata(output),
1685
- };
1686
- break;
1388
+ throw await deserializeAws_queryTooManyBucketsExceptionResponse(parsedOutput, context);
1687
1389
  default:
1688
1390
  const parsedBody = parsedOutput.body;
1689
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1690
- response = {
1691
- ...parsedBody.Error,
1692
- name: `${errorCode}`,
1693
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1391
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1392
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1694
1393
  $fault: "client",
1695
1394
  $metadata: deserializeMetadata(output),
1696
- };
1395
+ });
1396
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1697
1397
  }
1698
- const message = response.message || response.Message || errorCode;
1699
- response.message = message;
1700
- delete response.Message;
1701
- return Promise.reject(Object.assign(new Error(message), response));
1702
1398
  };
1703
1399
  const deserializeAws_queryDescribeEnvironmentHealthCommand = async (output, context) => {
1704
1400
  if (output.statusCode >= 300) {
@@ -1725,35 +1421,19 @@ const deserializeAws_queryDescribeEnvironmentHealthCommandError = async (output,
1725
1421
  switch (errorCode) {
1726
1422
  case "ElasticBeanstalkServiceException":
1727
1423
  case "com.amazonaws.elasticbeanstalk#ElasticBeanstalkServiceException":
1728
- response = {
1729
- ...(await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context)),
1730
- name: errorCode,
1731
- $metadata: deserializeMetadata(output),
1732
- };
1733
- break;
1424
+ throw await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context);
1734
1425
  case "InvalidRequestException":
1735
1426
  case "com.amazonaws.elasticbeanstalk#InvalidRequestException":
1736
- response = {
1737
- ...(await deserializeAws_queryInvalidRequestExceptionResponse(parsedOutput, context)),
1738
- name: errorCode,
1739
- $metadata: deserializeMetadata(output),
1740
- };
1741
- break;
1427
+ throw await deserializeAws_queryInvalidRequestExceptionResponse(parsedOutput, context);
1742
1428
  default:
1743
1429
  const parsedBody = parsedOutput.body;
1744
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1745
- response = {
1746
- ...parsedBody.Error,
1747
- name: `${errorCode}`,
1748
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1430
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1431
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1749
1432
  $fault: "client",
1750
1433
  $metadata: deserializeMetadata(output),
1751
- };
1434
+ });
1435
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1752
1436
  }
1753
- const message = response.message || response.Message || errorCode;
1754
- response.message = message;
1755
- delete response.Message;
1756
- return Promise.reject(Object.assign(new Error(message), response));
1757
1437
  };
1758
1438
  const deserializeAws_queryDescribeEnvironmentManagedActionHistoryCommand = async (output, context) => {
1759
1439
  if (output.statusCode >= 300) {
@@ -1780,27 +1460,16 @@ const deserializeAws_queryDescribeEnvironmentManagedActionHistoryCommandError =
1780
1460
  switch (errorCode) {
1781
1461
  case "ElasticBeanstalkServiceException":
1782
1462
  case "com.amazonaws.elasticbeanstalk#ElasticBeanstalkServiceException":
1783
- response = {
1784
- ...(await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context)),
1785
- name: errorCode,
1786
- $metadata: deserializeMetadata(output),
1787
- };
1788
- break;
1463
+ throw await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context);
1789
1464
  default:
1790
1465
  const parsedBody = parsedOutput.body;
1791
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1792
- response = {
1793
- ...parsedBody.Error,
1794
- name: `${errorCode}`,
1795
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1466
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1467
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1796
1468
  $fault: "client",
1797
1469
  $metadata: deserializeMetadata(output),
1798
- };
1470
+ });
1471
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1799
1472
  }
1800
- const message = response.message || response.Message || errorCode;
1801
- response.message = message;
1802
- delete response.Message;
1803
- return Promise.reject(Object.assign(new Error(message), response));
1804
1473
  };
1805
1474
  const deserializeAws_queryDescribeEnvironmentManagedActionsCommand = async (output, context) => {
1806
1475
  if (output.statusCode >= 300) {
@@ -1827,27 +1496,16 @@ const deserializeAws_queryDescribeEnvironmentManagedActionsCommandError = async
1827
1496
  switch (errorCode) {
1828
1497
  case "ElasticBeanstalkServiceException":
1829
1498
  case "com.amazonaws.elasticbeanstalk#ElasticBeanstalkServiceException":
1830
- response = {
1831
- ...(await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context)),
1832
- name: errorCode,
1833
- $metadata: deserializeMetadata(output),
1834
- };
1835
- break;
1499
+ throw await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context);
1836
1500
  default:
1837
1501
  const parsedBody = parsedOutput.body;
1838
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1839
- response = {
1840
- ...parsedBody.Error,
1841
- name: `${errorCode}`,
1842
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1502
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1503
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1843
1504
  $fault: "client",
1844
1505
  $metadata: deserializeMetadata(output),
1845
- };
1506
+ });
1507
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1846
1508
  }
1847
- const message = response.message || response.Message || errorCode;
1848
- response.message = message;
1849
- delete response.Message;
1850
- return Promise.reject(Object.assign(new Error(message), response));
1851
1509
  };
1852
1510
  const deserializeAws_queryDescribeEnvironmentResourcesCommand = async (output, context) => {
1853
1511
  if (output.statusCode >= 300) {
@@ -1874,27 +1532,16 @@ const deserializeAws_queryDescribeEnvironmentResourcesCommandError = async (outp
1874
1532
  switch (errorCode) {
1875
1533
  case "InsufficientPrivilegesException":
1876
1534
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
1877
- response = {
1878
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
1879
- name: errorCode,
1880
- $metadata: deserializeMetadata(output),
1881
- };
1882
- break;
1535
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
1883
1536
  default:
1884
1537
  const parsedBody = parsedOutput.body;
1885
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1886
- response = {
1887
- ...parsedBody.Error,
1888
- name: `${errorCode}`,
1889
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1538
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1539
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1890
1540
  $fault: "client",
1891
1541
  $metadata: deserializeMetadata(output),
1892
- };
1542
+ });
1543
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1893
1544
  }
1894
- const message = response.message || response.Message || errorCode;
1895
- response.message = message;
1896
- delete response.Message;
1897
- return Promise.reject(Object.assign(new Error(message), response));
1898
1545
  };
1899
1546
  const deserializeAws_queryDescribeEnvironmentsCommand = async (output, context) => {
1900
1547
  if (output.statusCode >= 300) {
@@ -1921,19 +1568,13 @@ const deserializeAws_queryDescribeEnvironmentsCommandError = async (output, cont
1921
1568
  switch (errorCode) {
1922
1569
  default:
1923
1570
  const parsedBody = parsedOutput.body;
1924
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1925
- response = {
1926
- ...parsedBody.Error,
1927
- name: `${errorCode}`,
1928
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1571
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1572
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1929
1573
  $fault: "client",
1930
1574
  $metadata: deserializeMetadata(output),
1931
- };
1575
+ });
1576
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1932
1577
  }
1933
- const message = response.message || response.Message || errorCode;
1934
- response.message = message;
1935
- delete response.Message;
1936
- return Promise.reject(Object.assign(new Error(message), response));
1937
1578
  };
1938
1579
  const deserializeAws_queryDescribeEventsCommand = async (output, context) => {
1939
1580
  if (output.statusCode >= 300) {
@@ -1960,19 +1601,13 @@ const deserializeAws_queryDescribeEventsCommandError = async (output, context) =
1960
1601
  switch (errorCode) {
1961
1602
  default:
1962
1603
  const parsedBody = parsedOutput.body;
1963
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
1964
- response = {
1965
- ...parsedBody.Error,
1966
- name: `${errorCode}`,
1967
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1604
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1605
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
1968
1606
  $fault: "client",
1969
1607
  $metadata: deserializeMetadata(output),
1970
- };
1608
+ });
1609
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
1971
1610
  }
1972
- const message = response.message || response.Message || errorCode;
1973
- response.message = message;
1974
- delete response.Message;
1975
- return Promise.reject(Object.assign(new Error(message), response));
1976
1611
  };
1977
1612
  const deserializeAws_queryDescribeInstancesHealthCommand = async (output, context) => {
1978
1613
  if (output.statusCode >= 300) {
@@ -1999,35 +1634,19 @@ const deserializeAws_queryDescribeInstancesHealthCommandError = async (output, c
1999
1634
  switch (errorCode) {
2000
1635
  case "ElasticBeanstalkServiceException":
2001
1636
  case "com.amazonaws.elasticbeanstalk#ElasticBeanstalkServiceException":
2002
- response = {
2003
- ...(await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context)),
2004
- name: errorCode,
2005
- $metadata: deserializeMetadata(output),
2006
- };
2007
- break;
1637
+ throw await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context);
2008
1638
  case "InvalidRequestException":
2009
1639
  case "com.amazonaws.elasticbeanstalk#InvalidRequestException":
2010
- response = {
2011
- ...(await deserializeAws_queryInvalidRequestExceptionResponse(parsedOutput, context)),
2012
- name: errorCode,
2013
- $metadata: deserializeMetadata(output),
2014
- };
2015
- break;
1640
+ throw await deserializeAws_queryInvalidRequestExceptionResponse(parsedOutput, context);
2016
1641
  default:
2017
1642
  const parsedBody = parsedOutput.body;
2018
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2019
- response = {
2020
- ...parsedBody.Error,
2021
- name: `${errorCode}`,
2022
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1643
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1644
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2023
1645
  $fault: "client",
2024
1646
  $metadata: deserializeMetadata(output),
2025
- };
1647
+ });
1648
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2026
1649
  }
2027
- const message = response.message || response.Message || errorCode;
2028
- response.message = message;
2029
- delete response.Message;
2030
- return Promise.reject(Object.assign(new Error(message), response));
2031
1650
  };
2032
1651
  const deserializeAws_queryDescribePlatformVersionCommand = async (output, context) => {
2033
1652
  if (output.statusCode >= 300) {
@@ -2054,35 +1673,19 @@ const deserializeAws_queryDescribePlatformVersionCommandError = async (output, c
2054
1673
  switch (errorCode) {
2055
1674
  case "ElasticBeanstalkServiceException":
2056
1675
  case "com.amazonaws.elasticbeanstalk#ElasticBeanstalkServiceException":
2057
- response = {
2058
- ...(await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context)),
2059
- name: errorCode,
2060
- $metadata: deserializeMetadata(output),
2061
- };
2062
- break;
1676
+ throw await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context);
2063
1677
  case "InsufficientPrivilegesException":
2064
1678
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
2065
- response = {
2066
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
2067
- name: errorCode,
2068
- $metadata: deserializeMetadata(output),
2069
- };
2070
- break;
1679
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
2071
1680
  default:
2072
1681
  const parsedBody = parsedOutput.body;
2073
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2074
- response = {
2075
- ...parsedBody.Error,
2076
- name: `${errorCode}`,
2077
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1682
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1683
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2078
1684
  $fault: "client",
2079
1685
  $metadata: deserializeMetadata(output),
2080
- };
1686
+ });
1687
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2081
1688
  }
2082
- const message = response.message || response.Message || errorCode;
2083
- response.message = message;
2084
- delete response.Message;
2085
- return Promise.reject(Object.assign(new Error(message), response));
2086
1689
  };
2087
1690
  const deserializeAws_queryDisassociateEnvironmentOperationsRoleCommand = async (output, context) => {
2088
1691
  if (output.statusCode >= 300) {
@@ -2106,27 +1709,16 @@ const deserializeAws_queryDisassociateEnvironmentOperationsRoleCommandError = as
2106
1709
  switch (errorCode) {
2107
1710
  case "InsufficientPrivilegesException":
2108
1711
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
2109
- response = {
2110
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
2111
- name: errorCode,
2112
- $metadata: deserializeMetadata(output),
2113
- };
2114
- break;
1712
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
2115
1713
  default:
2116
1714
  const parsedBody = parsedOutput.body;
2117
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2118
- response = {
2119
- ...parsedBody.Error,
2120
- name: `${errorCode}`,
2121
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1715
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1716
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2122
1717
  $fault: "client",
2123
1718
  $metadata: deserializeMetadata(output),
2124
- };
1719
+ });
1720
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2125
1721
  }
2126
- const message = response.message || response.Message || errorCode;
2127
- response.message = message;
2128
- delete response.Message;
2129
- return Promise.reject(Object.assign(new Error(message), response));
2130
1722
  };
2131
1723
  const deserializeAws_queryListAvailableSolutionStacksCommand = async (output, context) => {
2132
1724
  if (output.statusCode >= 300) {
@@ -2153,19 +1745,13 @@ const deserializeAws_queryListAvailableSolutionStacksCommandError = async (outpu
2153
1745
  switch (errorCode) {
2154
1746
  default:
2155
1747
  const parsedBody = parsedOutput.body;
2156
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2157
- response = {
2158
- ...parsedBody.Error,
2159
- name: `${errorCode}`,
2160
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1748
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1749
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2161
1750
  $fault: "client",
2162
1751
  $metadata: deserializeMetadata(output),
2163
- };
1752
+ });
1753
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2164
1754
  }
2165
- const message = response.message || response.Message || errorCode;
2166
- response.message = message;
2167
- delete response.Message;
2168
- return Promise.reject(Object.assign(new Error(message), response));
2169
1755
  };
2170
1756
  const deserializeAws_queryListPlatformBranchesCommand = async (output, context) => {
2171
1757
  if (output.statusCode >= 300) {
@@ -2192,19 +1778,13 @@ const deserializeAws_queryListPlatformBranchesCommandError = async (output, cont
2192
1778
  switch (errorCode) {
2193
1779
  default:
2194
1780
  const parsedBody = parsedOutput.body;
2195
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2196
- response = {
2197
- ...parsedBody.Error,
2198
- name: `${errorCode}`,
2199
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1781
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1782
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2200
1783
  $fault: "client",
2201
1784
  $metadata: deserializeMetadata(output),
2202
- };
1785
+ });
1786
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2203
1787
  }
2204
- const message = response.message || response.Message || errorCode;
2205
- response.message = message;
2206
- delete response.Message;
2207
- return Promise.reject(Object.assign(new Error(message), response));
2208
1788
  };
2209
1789
  const deserializeAws_queryListPlatformVersionsCommand = async (output, context) => {
2210
1790
  if (output.statusCode >= 300) {
@@ -2231,35 +1811,19 @@ const deserializeAws_queryListPlatformVersionsCommandError = async (output, cont
2231
1811
  switch (errorCode) {
2232
1812
  case "ElasticBeanstalkServiceException":
2233
1813
  case "com.amazonaws.elasticbeanstalk#ElasticBeanstalkServiceException":
2234
- response = {
2235
- ...(await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context)),
2236
- name: errorCode,
2237
- $metadata: deserializeMetadata(output),
2238
- };
2239
- break;
1814
+ throw await deserializeAws_queryElasticBeanstalkServiceExceptionResponse(parsedOutput, context);
2240
1815
  case "InsufficientPrivilegesException":
2241
1816
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
2242
- response = {
2243
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
2244
- name: errorCode,
2245
- $metadata: deserializeMetadata(output),
2246
- };
2247
- break;
1817
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
2248
1818
  default:
2249
1819
  const parsedBody = parsedOutput.body;
2250
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2251
- response = {
2252
- ...parsedBody.Error,
2253
- name: `${errorCode}`,
2254
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1820
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1821
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2255
1822
  $fault: "client",
2256
1823
  $metadata: deserializeMetadata(output),
2257
- };
1824
+ });
1825
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2258
1826
  }
2259
- const message = response.message || response.Message || errorCode;
2260
- response.message = message;
2261
- delete response.Message;
2262
- return Promise.reject(Object.assign(new Error(message), response));
2263
1827
  };
2264
1828
  const deserializeAws_queryListTagsForResourceCommand = async (output, context) => {
2265
1829
  if (output.statusCode >= 300) {
@@ -2286,43 +1850,22 @@ const deserializeAws_queryListTagsForResourceCommandError = async (output, conte
2286
1850
  switch (errorCode) {
2287
1851
  case "InsufficientPrivilegesException":
2288
1852
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
2289
- response = {
2290
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
2291
- name: errorCode,
2292
- $metadata: deserializeMetadata(output),
2293
- };
2294
- break;
1853
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
2295
1854
  case "ResourceNotFoundException":
2296
1855
  case "com.amazonaws.elasticbeanstalk#ResourceNotFoundException":
2297
- response = {
2298
- ...(await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context)),
2299
- name: errorCode,
2300
- $metadata: deserializeMetadata(output),
2301
- };
2302
- break;
1856
+ throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
2303
1857
  case "ResourceTypeNotSupportedException":
2304
1858
  case "com.amazonaws.elasticbeanstalk#ResourceTypeNotSupportedException":
2305
- response = {
2306
- ...(await deserializeAws_queryResourceTypeNotSupportedExceptionResponse(parsedOutput, context)),
2307
- name: errorCode,
2308
- $metadata: deserializeMetadata(output),
2309
- };
2310
- break;
1859
+ throw await deserializeAws_queryResourceTypeNotSupportedExceptionResponse(parsedOutput, context);
2311
1860
  default:
2312
1861
  const parsedBody = parsedOutput.body;
2313
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2314
- response = {
2315
- ...parsedBody.Error,
2316
- name: `${errorCode}`,
2317
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1862
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1863
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2318
1864
  $fault: "client",
2319
1865
  $metadata: deserializeMetadata(output),
2320
- };
1866
+ });
1867
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2321
1868
  }
2322
- const message = response.message || response.Message || errorCode;
2323
- response.message = message;
2324
- delete response.Message;
2325
- return Promise.reject(Object.assign(new Error(message), response));
2326
1869
  };
2327
1870
  const deserializeAws_queryRebuildEnvironmentCommand = async (output, context) => {
2328
1871
  if (output.statusCode >= 300) {
@@ -2346,27 +1889,16 @@ const deserializeAws_queryRebuildEnvironmentCommandError = async (output, contex
2346
1889
  switch (errorCode) {
2347
1890
  case "InsufficientPrivilegesException":
2348
1891
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
2349
- response = {
2350
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
2351
- name: errorCode,
2352
- $metadata: deserializeMetadata(output),
2353
- };
2354
- break;
1892
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
2355
1893
  default:
2356
1894
  const parsedBody = parsedOutput.body;
2357
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2358
- response = {
2359
- ...parsedBody.Error,
2360
- name: `${errorCode}`,
2361
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1895
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1896
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2362
1897
  $fault: "client",
2363
1898
  $metadata: deserializeMetadata(output),
2364
- };
1899
+ });
1900
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2365
1901
  }
2366
- const message = response.message || response.Message || errorCode;
2367
- response.message = message;
2368
- delete response.Message;
2369
- return Promise.reject(Object.assign(new Error(message), response));
2370
1902
  };
2371
1903
  const deserializeAws_queryRequestEnvironmentInfoCommand = async (output, context) => {
2372
1904
  if (output.statusCode >= 300) {
@@ -2390,19 +1922,13 @@ const deserializeAws_queryRequestEnvironmentInfoCommandError = async (output, co
2390
1922
  switch (errorCode) {
2391
1923
  default:
2392
1924
  const parsedBody = parsedOutput.body;
2393
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2394
- response = {
2395
- ...parsedBody.Error,
2396
- name: `${errorCode}`,
2397
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1925
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1926
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2398
1927
  $fault: "client",
2399
1928
  $metadata: deserializeMetadata(output),
2400
- };
1929
+ });
1930
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2401
1931
  }
2402
- const message = response.message || response.Message || errorCode;
2403
- response.message = message;
2404
- delete response.Message;
2405
- return Promise.reject(Object.assign(new Error(message), response));
2406
1932
  };
2407
1933
  const deserializeAws_queryRestartAppServerCommand = async (output, context) => {
2408
1934
  if (output.statusCode >= 300) {
@@ -2426,19 +1952,13 @@ const deserializeAws_queryRestartAppServerCommandError = async (output, context)
2426
1952
  switch (errorCode) {
2427
1953
  default:
2428
1954
  const parsedBody = parsedOutput.body;
2429
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2430
- response = {
2431
- ...parsedBody.Error,
2432
- name: `${errorCode}`,
2433
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1955
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1956
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2434
1957
  $fault: "client",
2435
1958
  $metadata: deserializeMetadata(output),
2436
- };
1959
+ });
1960
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2437
1961
  }
2438
- const message = response.message || response.Message || errorCode;
2439
- response.message = message;
2440
- delete response.Message;
2441
- return Promise.reject(Object.assign(new Error(message), response));
2442
1962
  };
2443
1963
  const deserializeAws_queryRetrieveEnvironmentInfoCommand = async (output, context) => {
2444
1964
  if (output.statusCode >= 300) {
@@ -2465,19 +1985,13 @@ const deserializeAws_queryRetrieveEnvironmentInfoCommandError = async (output, c
2465
1985
  switch (errorCode) {
2466
1986
  default:
2467
1987
  const parsedBody = parsedOutput.body;
2468
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2469
- response = {
2470
- ...parsedBody.Error,
2471
- name: `${errorCode}`,
2472
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
1988
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
1989
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2473
1990
  $fault: "client",
2474
1991
  $metadata: deserializeMetadata(output),
2475
- };
1992
+ });
1993
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2476
1994
  }
2477
- const message = response.message || response.Message || errorCode;
2478
- response.message = message;
2479
- delete response.Message;
2480
- return Promise.reject(Object.assign(new Error(message), response));
2481
1995
  };
2482
1996
  const deserializeAws_querySwapEnvironmentCNAMEsCommand = async (output, context) => {
2483
1997
  if (output.statusCode >= 300) {
@@ -2501,19 +2015,13 @@ const deserializeAws_querySwapEnvironmentCNAMEsCommandError = async (output, con
2501
2015
  switch (errorCode) {
2502
2016
  default:
2503
2017
  const parsedBody = parsedOutput.body;
2504
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2505
- response = {
2506
- ...parsedBody.Error,
2507
- name: `${errorCode}`,
2508
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
2018
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
2019
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2509
2020
  $fault: "client",
2510
2021
  $metadata: deserializeMetadata(output),
2511
- };
2022
+ });
2023
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2512
2024
  }
2513
- const message = response.message || response.Message || errorCode;
2514
- response.message = message;
2515
- delete response.Message;
2516
- return Promise.reject(Object.assign(new Error(message), response));
2517
2025
  };
2518
2026
  const deserializeAws_queryTerminateEnvironmentCommand = async (output, context) => {
2519
2027
  if (output.statusCode >= 300) {
@@ -2540,27 +2048,16 @@ const deserializeAws_queryTerminateEnvironmentCommandError = async (output, cont
2540
2048
  switch (errorCode) {
2541
2049
  case "InsufficientPrivilegesException":
2542
2050
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
2543
- response = {
2544
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
2545
- name: errorCode,
2546
- $metadata: deserializeMetadata(output),
2547
- };
2548
- break;
2051
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
2549
2052
  default:
2550
2053
  const parsedBody = parsedOutput.body;
2551
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2552
- response = {
2553
- ...parsedBody.Error,
2554
- name: `${errorCode}`,
2555
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
2054
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
2055
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2556
2056
  $fault: "client",
2557
2057
  $metadata: deserializeMetadata(output),
2558
- };
2058
+ });
2059
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2559
2060
  }
2560
- const message = response.message || response.Message || errorCode;
2561
- response.message = message;
2562
- delete response.Message;
2563
- return Promise.reject(Object.assign(new Error(message), response));
2564
2061
  };
2565
2062
  const deserializeAws_queryUpdateApplicationCommand = async (output, context) => {
2566
2063
  if (output.statusCode >= 300) {
@@ -2587,19 +2084,13 @@ const deserializeAws_queryUpdateApplicationCommandError = async (output, context
2587
2084
  switch (errorCode) {
2588
2085
  default:
2589
2086
  const parsedBody = parsedOutput.body;
2590
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2591
- response = {
2592
- ...parsedBody.Error,
2593
- name: `${errorCode}`,
2594
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
2087
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
2088
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2595
2089
  $fault: "client",
2596
2090
  $metadata: deserializeMetadata(output),
2597
- };
2091
+ });
2092
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2598
2093
  }
2599
- const message = response.message || response.Message || errorCode;
2600
- response.message = message;
2601
- delete response.Message;
2602
- return Promise.reject(Object.assign(new Error(message), response));
2603
2094
  };
2604
2095
  const deserializeAws_queryUpdateApplicationResourceLifecycleCommand = async (output, context) => {
2605
2096
  if (output.statusCode >= 300) {
@@ -2626,27 +2117,16 @@ const deserializeAws_queryUpdateApplicationResourceLifecycleCommandError = async
2626
2117
  switch (errorCode) {
2627
2118
  case "InsufficientPrivilegesException":
2628
2119
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
2629
- response = {
2630
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
2631
- name: errorCode,
2632
- $metadata: deserializeMetadata(output),
2633
- };
2634
- break;
2120
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
2635
2121
  default:
2636
2122
  const parsedBody = parsedOutput.body;
2637
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2638
- response = {
2639
- ...parsedBody.Error,
2640
- name: `${errorCode}`,
2641
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
2123
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
2124
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2642
2125
  $fault: "client",
2643
2126
  $metadata: deserializeMetadata(output),
2644
- };
2127
+ });
2128
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2645
2129
  }
2646
- const message = response.message || response.Message || errorCode;
2647
- response.message = message;
2648
- delete response.Message;
2649
- return Promise.reject(Object.assign(new Error(message), response));
2650
2130
  };
2651
2131
  const deserializeAws_queryUpdateApplicationVersionCommand = async (output, context) => {
2652
2132
  if (output.statusCode >= 300) {
@@ -2673,19 +2153,13 @@ const deserializeAws_queryUpdateApplicationVersionCommandError = async (output,
2673
2153
  switch (errorCode) {
2674
2154
  default:
2675
2155
  const parsedBody = parsedOutput.body;
2676
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2677
- response = {
2678
- ...parsedBody.Error,
2679
- name: `${errorCode}`,
2680
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
2156
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
2157
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2681
2158
  $fault: "client",
2682
2159
  $metadata: deserializeMetadata(output),
2683
- };
2160
+ });
2161
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2684
2162
  }
2685
- const message = response.message || response.Message || errorCode;
2686
- response.message = message;
2687
- delete response.Message;
2688
- return Promise.reject(Object.assign(new Error(message), response));
2689
2163
  };
2690
2164
  const deserializeAws_queryUpdateConfigurationTemplateCommand = async (output, context) => {
2691
2165
  if (output.statusCode >= 300) {
@@ -2712,35 +2186,19 @@ const deserializeAws_queryUpdateConfigurationTemplateCommandError = async (outpu
2712
2186
  switch (errorCode) {
2713
2187
  case "InsufficientPrivilegesException":
2714
2188
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
2715
- response = {
2716
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
2717
- name: errorCode,
2718
- $metadata: deserializeMetadata(output),
2719
- };
2720
- break;
2189
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
2721
2190
  case "TooManyBucketsException":
2722
2191
  case "com.amazonaws.elasticbeanstalk#TooManyBucketsException":
2723
- response = {
2724
- ...(await deserializeAws_queryTooManyBucketsExceptionResponse(parsedOutput, context)),
2725
- name: errorCode,
2726
- $metadata: deserializeMetadata(output),
2727
- };
2728
- break;
2192
+ throw await deserializeAws_queryTooManyBucketsExceptionResponse(parsedOutput, context);
2729
2193
  default:
2730
2194
  const parsedBody = parsedOutput.body;
2731
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2732
- response = {
2733
- ...parsedBody.Error,
2734
- name: `${errorCode}`,
2735
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
2195
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
2196
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2736
2197
  $fault: "client",
2737
2198
  $metadata: deserializeMetadata(output),
2738
- };
2199
+ });
2200
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2739
2201
  }
2740
- const message = response.message || response.Message || errorCode;
2741
- response.message = message;
2742
- delete response.Message;
2743
- return Promise.reject(Object.assign(new Error(message), response));
2744
2202
  };
2745
2203
  const deserializeAws_queryUpdateEnvironmentCommand = async (output, context) => {
2746
2204
  if (output.statusCode >= 300) {
@@ -2767,35 +2225,19 @@ const deserializeAws_queryUpdateEnvironmentCommandError = async (output, context
2767
2225
  switch (errorCode) {
2768
2226
  case "InsufficientPrivilegesException":
2769
2227
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
2770
- response = {
2771
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
2772
- name: errorCode,
2773
- $metadata: deserializeMetadata(output),
2774
- };
2775
- break;
2228
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
2776
2229
  case "TooManyBucketsException":
2777
2230
  case "com.amazonaws.elasticbeanstalk#TooManyBucketsException":
2778
- response = {
2779
- ...(await deserializeAws_queryTooManyBucketsExceptionResponse(parsedOutput, context)),
2780
- name: errorCode,
2781
- $metadata: deserializeMetadata(output),
2782
- };
2783
- break;
2231
+ throw await deserializeAws_queryTooManyBucketsExceptionResponse(parsedOutput, context);
2784
2232
  default:
2785
2233
  const parsedBody = parsedOutput.body;
2786
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2787
- response = {
2788
- ...parsedBody.Error,
2789
- name: `${errorCode}`,
2790
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
2234
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
2235
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2791
2236
  $fault: "client",
2792
2237
  $metadata: deserializeMetadata(output),
2793
- };
2238
+ });
2239
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2794
2240
  }
2795
- const message = response.message || response.Message || errorCode;
2796
- response.message = message;
2797
- delete response.Message;
2798
- return Promise.reject(Object.assign(new Error(message), response));
2799
2241
  };
2800
2242
  const deserializeAws_queryUpdateTagsForResourceCommand = async (output, context) => {
2801
2243
  if (output.statusCode >= 300) {
@@ -2819,59 +2261,28 @@ const deserializeAws_queryUpdateTagsForResourceCommandError = async (output, con
2819
2261
  switch (errorCode) {
2820
2262
  case "InsufficientPrivilegesException":
2821
2263
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
2822
- response = {
2823
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
2824
- name: errorCode,
2825
- $metadata: deserializeMetadata(output),
2826
- };
2827
- break;
2264
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
2828
2265
  case "OperationInProgressException":
2829
2266
  case "com.amazonaws.elasticbeanstalk#OperationInProgressException":
2830
- response = {
2831
- ...(await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)),
2832
- name: errorCode,
2833
- $metadata: deserializeMetadata(output),
2834
- };
2835
- break;
2267
+ throw await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context);
2836
2268
  case "ResourceNotFoundException":
2837
2269
  case "com.amazonaws.elasticbeanstalk#ResourceNotFoundException":
2838
- response = {
2839
- ...(await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context)),
2840
- name: errorCode,
2841
- $metadata: deserializeMetadata(output),
2842
- };
2843
- break;
2270
+ throw await deserializeAws_queryResourceNotFoundExceptionResponse(parsedOutput, context);
2844
2271
  case "ResourceTypeNotSupportedException":
2845
2272
  case "com.amazonaws.elasticbeanstalk#ResourceTypeNotSupportedException":
2846
- response = {
2847
- ...(await deserializeAws_queryResourceTypeNotSupportedExceptionResponse(parsedOutput, context)),
2848
- name: errorCode,
2849
- $metadata: deserializeMetadata(output),
2850
- };
2851
- break;
2273
+ throw await deserializeAws_queryResourceTypeNotSupportedExceptionResponse(parsedOutput, context);
2852
2274
  case "TooManyTagsException":
2853
2275
  case "com.amazonaws.elasticbeanstalk#TooManyTagsException":
2854
- response = {
2855
- ...(await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context)),
2856
- name: errorCode,
2857
- $metadata: deserializeMetadata(output),
2858
- };
2859
- break;
2276
+ throw await deserializeAws_queryTooManyTagsExceptionResponse(parsedOutput, context);
2860
2277
  default:
2861
2278
  const parsedBody = parsedOutput.body;
2862
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2863
- response = {
2864
- ...parsedBody.Error,
2865
- name: `${errorCode}`,
2866
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
2279
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
2280
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2867
2281
  $fault: "client",
2868
2282
  $metadata: deserializeMetadata(output),
2869
- };
2283
+ });
2284
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2870
2285
  }
2871
- const message = response.message || response.Message || errorCode;
2872
- response.message = message;
2873
- delete response.Message;
2874
- return Promise.reject(Object.assign(new Error(message), response));
2875
2286
  };
2876
2287
  const deserializeAws_queryValidateConfigurationSettingsCommand = async (output, context) => {
2877
2288
  if (output.statusCode >= 300) {
@@ -2898,244 +2309,190 @@ const deserializeAws_queryValidateConfigurationSettingsCommandError = async (out
2898
2309
  switch (errorCode) {
2899
2310
  case "InsufficientPrivilegesException":
2900
2311
  case "com.amazonaws.elasticbeanstalk#InsufficientPrivilegesException":
2901
- response = {
2902
- ...(await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context)),
2903
- name: errorCode,
2904
- $metadata: deserializeMetadata(output),
2905
- };
2906
- break;
2312
+ throw await deserializeAws_queryInsufficientPrivilegesExceptionResponse(parsedOutput, context);
2907
2313
  case "TooManyBucketsException":
2908
2314
  case "com.amazonaws.elasticbeanstalk#TooManyBucketsException":
2909
- response = {
2910
- ...(await deserializeAws_queryTooManyBucketsExceptionResponse(parsedOutput, context)),
2911
- name: errorCode,
2912
- $metadata: deserializeMetadata(output),
2913
- };
2914
- break;
2315
+ throw await deserializeAws_queryTooManyBucketsExceptionResponse(parsedOutput, context);
2915
2316
  default:
2916
2317
  const parsedBody = parsedOutput.body;
2917
- errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
2918
- response = {
2919
- ...parsedBody.Error,
2920
- name: `${errorCode}`,
2921
- message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
2318
+ response = new ElasticBeanstalkServiceException_1.ElasticBeanstalkServiceException({
2319
+ name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
2922
2320
  $fault: "client",
2923
2321
  $metadata: deserializeMetadata(output),
2924
- };
2322
+ });
2323
+ throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
2925
2324
  }
2926
- const message = response.message || response.Message || errorCode;
2927
- response.message = message;
2928
- delete response.Message;
2929
- return Promise.reject(Object.assign(new Error(message), response));
2930
2325
  };
2931
2326
  const deserializeAws_queryCodeBuildNotInServiceRegionExceptionResponse = async (parsedOutput, context) => {
2932
2327
  const body = parsedOutput.body;
2933
2328
  const deserialized = deserializeAws_queryCodeBuildNotInServiceRegionException(body.Error, context);
2934
- const contents = {
2935
- name: "CodeBuildNotInServiceRegionException",
2936
- $fault: "client",
2329
+ const exception = new models_0_1.CodeBuildNotInServiceRegionException({
2937
2330
  $metadata: deserializeMetadata(parsedOutput),
2938
2331
  ...deserialized,
2939
- };
2940
- return contents;
2332
+ });
2333
+ return smithy_client_1.decorateServiceException(exception, body);
2941
2334
  };
2942
2335
  const deserializeAws_queryElasticBeanstalkServiceExceptionResponse = async (parsedOutput, context) => {
2943
2336
  const body = parsedOutput.body;
2944
2337
  const deserialized = deserializeAws_queryElasticBeanstalkServiceException(body.Error, context);
2945
- const contents = {
2946
- name: "ElasticBeanstalkServiceException",
2947
- $fault: "client",
2338
+ const exception = new models_0_1.ElasticBeanstalkServiceException({
2948
2339
  $metadata: deserializeMetadata(parsedOutput),
2949
2340
  ...deserialized,
2950
- };
2951
- return contents;
2341
+ });
2342
+ return smithy_client_1.decorateServiceException(exception, body);
2952
2343
  };
2953
2344
  const deserializeAws_queryInsufficientPrivilegesExceptionResponse = async (parsedOutput, context) => {
2954
2345
  const body = parsedOutput.body;
2955
2346
  const deserialized = deserializeAws_queryInsufficientPrivilegesException(body.Error, context);
2956
- const contents = {
2957
- name: "InsufficientPrivilegesException",
2958
- $fault: "client",
2347
+ const exception = new models_0_1.InsufficientPrivilegesException({
2959
2348
  $metadata: deserializeMetadata(parsedOutput),
2960
2349
  ...deserialized,
2961
- };
2962
- return contents;
2350
+ });
2351
+ return smithy_client_1.decorateServiceException(exception, body);
2963
2352
  };
2964
2353
  const deserializeAws_queryInvalidRequestExceptionResponse = async (parsedOutput, context) => {
2965
2354
  const body = parsedOutput.body;
2966
2355
  const deserialized = deserializeAws_queryInvalidRequestException(body.Error, context);
2967
- const contents = {
2968
- name: "InvalidRequestException",
2969
- $fault: "client",
2356
+ const exception = new models_0_1.InvalidRequestException({
2970
2357
  $metadata: deserializeMetadata(parsedOutput),
2971
2358
  ...deserialized,
2972
- };
2973
- return contents;
2359
+ });
2360
+ return smithy_client_1.decorateServiceException(exception, body);
2974
2361
  };
2975
2362
  const deserializeAws_queryManagedActionInvalidStateExceptionResponse = async (parsedOutput, context) => {
2976
2363
  const body = parsedOutput.body;
2977
2364
  const deserialized = deserializeAws_queryManagedActionInvalidStateException(body.Error, context);
2978
- const contents = {
2979
- name: "ManagedActionInvalidStateException",
2980
- $fault: "client",
2365
+ const exception = new models_0_1.ManagedActionInvalidStateException({
2981
2366
  $metadata: deserializeMetadata(parsedOutput),
2982
2367
  ...deserialized,
2983
- };
2984
- return contents;
2368
+ });
2369
+ return smithy_client_1.decorateServiceException(exception, body);
2985
2370
  };
2986
2371
  const deserializeAws_queryOperationInProgressExceptionResponse = async (parsedOutput, context) => {
2987
2372
  const body = parsedOutput.body;
2988
2373
  const deserialized = deserializeAws_queryOperationInProgressException(body.Error, context);
2989
- const contents = {
2990
- name: "OperationInProgressException",
2991
- $fault: "client",
2374
+ const exception = new models_0_1.OperationInProgressException({
2992
2375
  $metadata: deserializeMetadata(parsedOutput),
2993
2376
  ...deserialized,
2994
- };
2995
- return contents;
2377
+ });
2378
+ return smithy_client_1.decorateServiceException(exception, body);
2996
2379
  };
2997
2380
  const deserializeAws_queryPlatformVersionStillReferencedExceptionResponse = async (parsedOutput, context) => {
2998
2381
  const body = parsedOutput.body;
2999
2382
  const deserialized = deserializeAws_queryPlatformVersionStillReferencedException(body.Error, context);
3000
- const contents = {
3001
- name: "PlatformVersionStillReferencedException",
3002
- $fault: "client",
2383
+ const exception = new models_0_1.PlatformVersionStillReferencedException({
3003
2384
  $metadata: deserializeMetadata(parsedOutput),
3004
2385
  ...deserialized,
3005
- };
3006
- return contents;
2386
+ });
2387
+ return smithy_client_1.decorateServiceException(exception, body);
3007
2388
  };
3008
2389
  const deserializeAws_queryResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
3009
2390
  const body = parsedOutput.body;
3010
2391
  const deserialized = deserializeAws_queryResourceNotFoundException(body.Error, context);
3011
- const contents = {
3012
- name: "ResourceNotFoundException",
3013
- $fault: "client",
2392
+ const exception = new models_0_1.ResourceNotFoundException({
3014
2393
  $metadata: deserializeMetadata(parsedOutput),
3015
2394
  ...deserialized,
3016
- };
3017
- return contents;
2395
+ });
2396
+ return smithy_client_1.decorateServiceException(exception, body);
3018
2397
  };
3019
2398
  const deserializeAws_queryResourceTypeNotSupportedExceptionResponse = async (parsedOutput, context) => {
3020
2399
  const body = parsedOutput.body;
3021
2400
  const deserialized = deserializeAws_queryResourceTypeNotSupportedException(body.Error, context);
3022
- const contents = {
3023
- name: "ResourceTypeNotSupportedException",
3024
- $fault: "client",
2401
+ const exception = new models_0_1.ResourceTypeNotSupportedException({
3025
2402
  $metadata: deserializeMetadata(parsedOutput),
3026
2403
  ...deserialized,
3027
- };
3028
- return contents;
2404
+ });
2405
+ return smithy_client_1.decorateServiceException(exception, body);
3029
2406
  };
3030
2407
  const deserializeAws_queryS3LocationNotInServiceRegionExceptionResponse = async (parsedOutput, context) => {
3031
2408
  const body = parsedOutput.body;
3032
2409
  const deserialized = deserializeAws_queryS3LocationNotInServiceRegionException(body.Error, context);
3033
- const contents = {
3034
- name: "S3LocationNotInServiceRegionException",
3035
- $fault: "client",
2410
+ const exception = new models_0_1.S3LocationNotInServiceRegionException({
3036
2411
  $metadata: deserializeMetadata(parsedOutput),
3037
2412
  ...deserialized,
3038
- };
3039
- return contents;
2413
+ });
2414
+ return smithy_client_1.decorateServiceException(exception, body);
3040
2415
  };
3041
2416
  const deserializeAws_queryS3SubscriptionRequiredExceptionResponse = async (parsedOutput, context) => {
3042
2417
  const body = parsedOutput.body;
3043
2418
  const deserialized = deserializeAws_queryS3SubscriptionRequiredException(body.Error, context);
3044
- const contents = {
3045
- name: "S3SubscriptionRequiredException",
3046
- $fault: "client",
2419
+ const exception = new models_0_1.S3SubscriptionRequiredException({
3047
2420
  $metadata: deserializeMetadata(parsedOutput),
3048
2421
  ...deserialized,
3049
- };
3050
- return contents;
2422
+ });
2423
+ return smithy_client_1.decorateServiceException(exception, body);
3051
2424
  };
3052
2425
  const deserializeAws_querySourceBundleDeletionExceptionResponse = async (parsedOutput, context) => {
3053
2426
  const body = parsedOutput.body;
3054
2427
  const deserialized = deserializeAws_querySourceBundleDeletionException(body.Error, context);
3055
- const contents = {
3056
- name: "SourceBundleDeletionException",
3057
- $fault: "client",
2428
+ const exception = new models_0_1.SourceBundleDeletionException({
3058
2429
  $metadata: deserializeMetadata(parsedOutput),
3059
2430
  ...deserialized,
3060
- };
3061
- return contents;
2431
+ });
2432
+ return smithy_client_1.decorateServiceException(exception, body);
3062
2433
  };
3063
2434
  const deserializeAws_queryTooManyApplicationsExceptionResponse = async (parsedOutput, context) => {
3064
2435
  const body = parsedOutput.body;
3065
2436
  const deserialized = deserializeAws_queryTooManyApplicationsException(body.Error, context);
3066
- const contents = {
3067
- name: "TooManyApplicationsException",
3068
- $fault: "client",
2437
+ const exception = new models_0_1.TooManyApplicationsException({
3069
2438
  $metadata: deserializeMetadata(parsedOutput),
3070
2439
  ...deserialized,
3071
- };
3072
- return contents;
2440
+ });
2441
+ return smithy_client_1.decorateServiceException(exception, body);
3073
2442
  };
3074
2443
  const deserializeAws_queryTooManyApplicationVersionsExceptionResponse = async (parsedOutput, context) => {
3075
2444
  const body = parsedOutput.body;
3076
2445
  const deserialized = deserializeAws_queryTooManyApplicationVersionsException(body.Error, context);
3077
- const contents = {
3078
- name: "TooManyApplicationVersionsException",
3079
- $fault: "client",
2446
+ const exception = new models_0_1.TooManyApplicationVersionsException({
3080
2447
  $metadata: deserializeMetadata(parsedOutput),
3081
2448
  ...deserialized,
3082
- };
3083
- return contents;
2449
+ });
2450
+ return smithy_client_1.decorateServiceException(exception, body);
3084
2451
  };
3085
2452
  const deserializeAws_queryTooManyBucketsExceptionResponse = async (parsedOutput, context) => {
3086
2453
  const body = parsedOutput.body;
3087
2454
  const deserialized = deserializeAws_queryTooManyBucketsException(body.Error, context);
3088
- const contents = {
3089
- name: "TooManyBucketsException",
3090
- $fault: "client",
2455
+ const exception = new models_0_1.TooManyBucketsException({
3091
2456
  $metadata: deserializeMetadata(parsedOutput),
3092
2457
  ...deserialized,
3093
- };
3094
- return contents;
2458
+ });
2459
+ return smithy_client_1.decorateServiceException(exception, body);
3095
2460
  };
3096
2461
  const deserializeAws_queryTooManyConfigurationTemplatesExceptionResponse = async (parsedOutput, context) => {
3097
2462
  const body = parsedOutput.body;
3098
2463
  const deserialized = deserializeAws_queryTooManyConfigurationTemplatesException(body.Error, context);
3099
- const contents = {
3100
- name: "TooManyConfigurationTemplatesException",
3101
- $fault: "client",
2464
+ const exception = new models_0_1.TooManyConfigurationTemplatesException({
3102
2465
  $metadata: deserializeMetadata(parsedOutput),
3103
2466
  ...deserialized,
3104
- };
3105
- return contents;
2467
+ });
2468
+ return smithy_client_1.decorateServiceException(exception, body);
3106
2469
  };
3107
2470
  const deserializeAws_queryTooManyEnvironmentsExceptionResponse = async (parsedOutput, context) => {
3108
2471
  const body = parsedOutput.body;
3109
2472
  const deserialized = deserializeAws_queryTooManyEnvironmentsException(body.Error, context);
3110
- const contents = {
3111
- name: "TooManyEnvironmentsException",
3112
- $fault: "client",
2473
+ const exception = new models_0_1.TooManyEnvironmentsException({
3113
2474
  $metadata: deserializeMetadata(parsedOutput),
3114
2475
  ...deserialized,
3115
- };
3116
- return contents;
2476
+ });
2477
+ return smithy_client_1.decorateServiceException(exception, body);
3117
2478
  };
3118
2479
  const deserializeAws_queryTooManyPlatformsExceptionResponse = async (parsedOutput, context) => {
3119
2480
  const body = parsedOutput.body;
3120
2481
  const deserialized = deserializeAws_queryTooManyPlatformsException(body.Error, context);
3121
- const contents = {
3122
- name: "TooManyPlatformsException",
3123
- $fault: "client",
2482
+ const exception = new models_0_1.TooManyPlatformsException({
3124
2483
  $metadata: deserializeMetadata(parsedOutput),
3125
2484
  ...deserialized,
3126
- };
3127
- return contents;
2485
+ });
2486
+ return smithy_client_1.decorateServiceException(exception, body);
3128
2487
  };
3129
2488
  const deserializeAws_queryTooManyTagsExceptionResponse = async (parsedOutput, context) => {
3130
2489
  const body = parsedOutput.body;
3131
2490
  const deserialized = deserializeAws_queryTooManyTagsException(body.Error, context);
3132
- const contents = {
3133
- name: "TooManyTagsException",
3134
- $fault: "client",
2491
+ const exception = new models_0_1.TooManyTagsException({
3135
2492
  $metadata: deserializeMetadata(parsedOutput),
3136
2493
  ...deserialized,
3137
- };
3138
- return contents;
2494
+ });
2495
+ return smithy_client_1.decorateServiceException(exception, body);
3139
2496
  };
3140
2497
  const serializeAws_queryAbortEnvironmentUpdateMessage = (input, context) => {
3141
2498
  const entries = {};