@aws-sdk/client-managedblockchain 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/ManagedBlockchainServiceException.js +11 -0
  4. package/dist-cjs/models/models_0.js +144 -2
  5. package/dist-cjs/protocols/Aws_restJson1.js +296 -1064
  6. package/dist-es/index.js +1 -0
  7. package/dist-es/models/ManagedBlockchainServiceException.js +12 -0
  8. package/dist-es/models/models_0.js +132 -1
  9. package/dist-es/protocols/Aws_restJson1.js +587 -1167
  10. package/dist-types/index.d.ts +1 -0
  11. package/dist-types/models/ManagedBlockchainServiceException.d.ts +10 -0
  12. package/dist-types/models/models_0.d.ts +72 -31
  13. package/dist-types/ts3.4/index.d.ts +1 -0
  14. package/dist-types/ts3.4/models/ManagedBlockchainServiceException.d.ts +6 -0
  15. package/dist-types/ts3.4/models/models_0.d.ts +52 -31
  16. package/package.json +25 -25
package/dist-cjs/protocols/Aws_restJson1.js CHANGED
@@ -4,6 +4,8 @@ exports.deserializeAws_restJson1VoteOnProposalCommand = exports.deserializeAws_r
4
4
  const protocol_http_1 = require("@aws-sdk/protocol-http");
5
5
  const smithy_client_1 = require("@aws-sdk/smithy-client");
6
6
  const uuid_1 = require("uuid");
7
+ const ManagedBlockchainServiceException_1 = require("../models/ManagedBlockchainServiceException");
8
+ const models_0_1 = require("../models/models_0");
7
9
  const serializeAws_restJson1CreateMemberCommand = async (input, context) => {
8
10
  var _a;
9
11
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
@@ -829,91 +831,40 @@ const deserializeAws_restJson1CreateMemberCommandError = async (output, context)
829
831
  switch (errorCode) {
830
832
  case "AccessDeniedException":
831
833
  case "com.amazonaws.managedblockchain#AccessDeniedException":
832
- response = {
833
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
834
- name: errorCode,
835
- $metadata: deserializeMetadata(output),
836
- };
837
- break;
834
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
838
835
  case "InternalServiceErrorException":
839
836
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
840
- response = {
841
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
842
- name: errorCode,
843
- $metadata: deserializeMetadata(output),
844
- };
845
- break;
837
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
846
838
  case "InvalidRequestException":
847
839
  case "com.amazonaws.managedblockchain#InvalidRequestException":
848
- response = {
849
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
850
- name: errorCode,
851
- $metadata: deserializeMetadata(output),
852
- };
853
- break;
840
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
854
841
  case "ResourceAlreadyExistsException":
855
842
  case "com.amazonaws.managedblockchain#ResourceAlreadyExistsException":
856
- response = {
857
- ...(await deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse(parsedOutput, context)),
858
- name: errorCode,
859
- $metadata: deserializeMetadata(output),
860
- };
861
- break;
843
+ throw await deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
862
844
  case "ResourceLimitExceededException":
863
845
  case "com.amazonaws.managedblockchain#ResourceLimitExceededException":
864
- response = {
865
- ...(await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context)),
866
- name: errorCode,
867
- $metadata: deserializeMetadata(output),
868
- };
869
- break;
846
+ throw await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context);
870
847
  case "ResourceNotFoundException":
871
848
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
872
- response = {
873
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
874
- name: errorCode,
875
- $metadata: deserializeMetadata(output),
876
- };
877
- break;
849
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
878
850
  case "ResourceNotReadyException":
879
851
  case "com.amazonaws.managedblockchain#ResourceNotReadyException":
880
- response = {
881
- ...(await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context)),
882
- name: errorCode,
883
- $metadata: deserializeMetadata(output),
884
- };
885
- break;
852
+ throw await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context);
886
853
  case "ThrottlingException":
887
854
  case "com.amazonaws.managedblockchain#ThrottlingException":
888
- response = {
889
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
890
- name: errorCode,
891
- $metadata: deserializeMetadata(output),
892
- };
893
- break;
855
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
894
856
  case "TooManyTagsException":
895
857
  case "com.amazonaws.managedblockchain#TooManyTagsException":
896
- response = {
897
- ...(await deserializeAws_restJson1TooManyTagsExceptionResponse(parsedOutput, context)),
898
- name: errorCode,
899
- $metadata: deserializeMetadata(output),
900
- };
901
- break;
858
+ throw await deserializeAws_restJson1TooManyTagsExceptionResponse(parsedOutput, context);
902
859
  default:
903
860
  const parsedBody = parsedOutput.body;
904
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
905
- response = {
906
- ...parsedBody,
907
- name: `${errorCode}`,
908
- message: parsedBody.message || parsedBody.Message || errorCode,
861
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
862
+ name: parsedBody.code || parsedBody.Code || errorCode,
909
863
  $fault: "client",
910
864
  $metadata: deserializeMetadata(output),
911
- };
865
+ });
866
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
912
867
  }
913
- const message = response.message || response.Message || errorCode;
914
- response.message = message;
915
- delete response.Message;
916
- return Promise.reject(Object.assign(new Error(message), response));
917
868
  };
918
869
  const deserializeAws_restJson1CreateNetworkCommand = async (output, context) => {
919
870
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -945,75 +896,34 @@ const deserializeAws_restJson1CreateNetworkCommandError = async (output, context
945
896
  switch (errorCode) {
946
897
  case "AccessDeniedException":
947
898
  case "com.amazonaws.managedblockchain#AccessDeniedException":
948
- response = {
949
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
950
- name: errorCode,
951
- $metadata: deserializeMetadata(output),
952
- };
953
- break;
899
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
954
900
  case "InternalServiceErrorException":
955
901
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
956
- response = {
957
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
958
- name: errorCode,
959
- $metadata: deserializeMetadata(output),
960
- };
961
- break;
902
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
962
903
  case "InvalidRequestException":
963
904
  case "com.amazonaws.managedblockchain#InvalidRequestException":
964
- response = {
965
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
966
- name: errorCode,
967
- $metadata: deserializeMetadata(output),
968
- };
969
- break;
905
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
970
906
  case "ResourceAlreadyExistsException":
971
907
  case "com.amazonaws.managedblockchain#ResourceAlreadyExistsException":
972
- response = {
973
- ...(await deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse(parsedOutput, context)),
974
- name: errorCode,
975
- $metadata: deserializeMetadata(output),
976
- };
977
- break;
908
+ throw await deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
978
909
  case "ResourceLimitExceededException":
979
910
  case "com.amazonaws.managedblockchain#ResourceLimitExceededException":
980
- response = {
981
- ...(await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context)),
982
- name: errorCode,
983
- $metadata: deserializeMetadata(output),
984
- };
985
- break;
911
+ throw await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context);
986
912
  case "ThrottlingException":
987
913
  case "com.amazonaws.managedblockchain#ThrottlingException":
988
- response = {
989
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
990
- name: errorCode,
991
- $metadata: deserializeMetadata(output),
992
- };
993
- break;
914
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
994
915
  case "TooManyTagsException":
995
916
  case "com.amazonaws.managedblockchain#TooManyTagsException":
996
- response = {
997
- ...(await deserializeAws_restJson1TooManyTagsExceptionResponse(parsedOutput, context)),
998
- name: errorCode,
999
- $metadata: deserializeMetadata(output),
1000
- };
1001
- break;
917
+ throw await deserializeAws_restJson1TooManyTagsExceptionResponse(parsedOutput, context);
1002
918
  default:
1003
919
  const parsedBody = parsedOutput.body;
1004
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1005
- response = {
1006
- ...parsedBody,
1007
- name: `${errorCode}`,
1008
- message: parsedBody.message || parsedBody.Message || errorCode,
920
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
921
+ name: parsedBody.code || parsedBody.Code || errorCode,
1009
922
  $fault: "client",
1010
923
  $metadata: deserializeMetadata(output),
1011
- };
924
+ });
925
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1012
926
  }
1013
- const message = response.message || response.Message || errorCode;
1014
- response.message = message;
1015
- delete response.Message;
1016
- return Promise.reject(Object.assign(new Error(message), response));
1017
927
  };
1018
928
  const deserializeAws_restJson1CreateNodeCommand = async (output, context) => {
1019
929
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1041,91 +951,40 @@ const deserializeAws_restJson1CreateNodeCommandError = async (output, context) =
1041
951
  switch (errorCode) {
1042
952
  case "AccessDeniedException":
1043
953
  case "com.amazonaws.managedblockchain#AccessDeniedException":
1044
- response = {
1045
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
1046
- name: errorCode,
1047
- $metadata: deserializeMetadata(output),
1048
- };
1049
- break;
954
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
1050
955
  case "InternalServiceErrorException":
1051
956
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
1052
- response = {
1053
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
1054
- name: errorCode,
1055
- $metadata: deserializeMetadata(output),
1056
- };
1057
- break;
957
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
1058
958
  case "InvalidRequestException":
1059
959
  case "com.amazonaws.managedblockchain#InvalidRequestException":
1060
- response = {
1061
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
1062
- name: errorCode,
1063
- $metadata: deserializeMetadata(output),
1064
- };
1065
- break;
960
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
1066
961
  case "ResourceAlreadyExistsException":
1067
962
  case "com.amazonaws.managedblockchain#ResourceAlreadyExistsException":
1068
- response = {
1069
- ...(await deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse(parsedOutput, context)),
1070
- name: errorCode,
1071
- $metadata: deserializeMetadata(output),
1072
- };
1073
- break;
963
+ throw await deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse(parsedOutput, context);
1074
964
  case "ResourceLimitExceededException":
1075
965
  case "com.amazonaws.managedblockchain#ResourceLimitExceededException":
1076
- response = {
1077
- ...(await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context)),
1078
- name: errorCode,
1079
- $metadata: deserializeMetadata(output),
1080
- };
1081
- break;
966
+ throw await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context);
1082
967
  case "ResourceNotFoundException":
1083
968
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
1084
- response = {
1085
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1086
- name: errorCode,
1087
- $metadata: deserializeMetadata(output),
1088
- };
1089
- break;
969
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
1090
970
  case "ResourceNotReadyException":
1091
971
  case "com.amazonaws.managedblockchain#ResourceNotReadyException":
1092
- response = {
1093
- ...(await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context)),
1094
- name: errorCode,
1095
- $metadata: deserializeMetadata(output),
1096
- };
1097
- break;
972
+ throw await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context);
1098
973
  case "ThrottlingException":
1099
974
  case "com.amazonaws.managedblockchain#ThrottlingException":
1100
- response = {
1101
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
1102
- name: errorCode,
1103
- $metadata: deserializeMetadata(output),
1104
- };
1105
- break;
975
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
1106
976
  case "TooManyTagsException":
1107
977
  case "com.amazonaws.managedblockchain#TooManyTagsException":
1108
- response = {
1109
- ...(await deserializeAws_restJson1TooManyTagsExceptionResponse(parsedOutput, context)),
1110
- name: errorCode,
1111
- $metadata: deserializeMetadata(output),
1112
- };
1113
- break;
978
+ throw await deserializeAws_restJson1TooManyTagsExceptionResponse(parsedOutput, context);
1114
979
  default:
1115
980
  const parsedBody = parsedOutput.body;
1116
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1117
- response = {
1118
- ...parsedBody,
1119
- name: `${errorCode}`,
1120
- message: parsedBody.message || parsedBody.Message || errorCode,
981
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
982
+ name: parsedBody.code || parsedBody.Code || errorCode,
1121
983
  $fault: "client",
1122
984
  $metadata: deserializeMetadata(output),
1123
- };
985
+ });
986
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1124
987
  }
1125
- const message = response.message || response.Message || errorCode;
1126
- response.message = message;
1127
- delete response.Message;
1128
- return Promise.reject(Object.assign(new Error(message), response));
1129
988
  };
1130
989
  const deserializeAws_restJson1CreateProposalCommand = async (output, context) => {
1131
990
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1153,75 +1012,34 @@ const deserializeAws_restJson1CreateProposalCommandError = async (output, contex
1153
1012
  switch (errorCode) {
1154
1013
  case "AccessDeniedException":
1155
1014
  case "com.amazonaws.managedblockchain#AccessDeniedException":
1156
- response = {
1157
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
1158
- name: errorCode,
1159
- $metadata: deserializeMetadata(output),
1160
- };
1161
- break;
1015
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
1162
1016
  case "InternalServiceErrorException":
1163
1017
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
1164
- response = {
1165
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
1166
- name: errorCode,
1167
- $metadata: deserializeMetadata(output),
1168
- };
1169
- break;
1018
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
1170
1019
  case "InvalidRequestException":
1171
1020
  case "com.amazonaws.managedblockchain#InvalidRequestException":
1172
- response = {
1173
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
1174
- name: errorCode,
1175
- $metadata: deserializeMetadata(output),
1176
- };
1177
- break;
1021
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
1178
1022
  case "ResourceNotFoundException":
1179
1023
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
1180
- response = {
1181
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1182
- name: errorCode,
1183
- $metadata: deserializeMetadata(output),
1184
- };
1185
- break;
1024
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
1186
1025
  case "ResourceNotReadyException":
1187
1026
  case "com.amazonaws.managedblockchain#ResourceNotReadyException":
1188
- response = {
1189
- ...(await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context)),
1190
- name: errorCode,
1191
- $metadata: deserializeMetadata(output),
1192
- };
1193
- break;
1027
+ throw await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context);
1194
1028
  case "ThrottlingException":
1195
1029
  case "com.amazonaws.managedblockchain#ThrottlingException":
1196
- response = {
1197
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
1198
- name: errorCode,
1199
- $metadata: deserializeMetadata(output),
1200
- };
1201
- break;
1030
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
1202
1031
  case "TooManyTagsException":
1203
1032
  case "com.amazonaws.managedblockchain#TooManyTagsException":
1204
- response = {
1205
- ...(await deserializeAws_restJson1TooManyTagsExceptionResponse(parsedOutput, context)),
1206
- name: errorCode,
1207
- $metadata: deserializeMetadata(output),
1208
- };
1209
- break;
1033
+ throw await deserializeAws_restJson1TooManyTagsExceptionResponse(parsedOutput, context);
1210
1034
  default:
1211
1035
  const parsedBody = parsedOutput.body;
1212
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1213
- response = {
1214
- ...parsedBody,
1215
- name: `${errorCode}`,
1216
- message: parsedBody.message || parsedBody.Message || errorCode,
1036
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1037
+ name: parsedBody.code || parsedBody.Code || errorCode,
1217
1038
  $fault: "client",
1218
1039
  $metadata: deserializeMetadata(output),
1219
- };
1040
+ });
1041
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1220
1042
  }
1221
- const message = response.message || response.Message || errorCode;
1222
- response.message = message;
1223
- delete response.Message;
1224
- return Promise.reject(Object.assign(new Error(message), response));
1225
1043
  };
1226
1044
  const deserializeAws_restJson1DeleteMemberCommand = async (output, context) => {
1227
1045
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1245,67 +1063,31 @@ const deserializeAws_restJson1DeleteMemberCommandError = async (output, context)
1245
1063
  switch (errorCode) {
1246
1064
  case "AccessDeniedException":
1247
1065
  case "com.amazonaws.managedblockchain#AccessDeniedException":
1248
- response = {
1249
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
1250
- name: errorCode,
1251
- $metadata: deserializeMetadata(output),
1252
- };
1253
- break;
1066
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
1254
1067
  case "InternalServiceErrorException":
1255
1068
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
1256
- response = {
1257
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
1258
- name: errorCode,
1259
- $metadata: deserializeMetadata(output),
1260
- };
1261
- break;
1069
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
1262
1070
  case "InvalidRequestException":
1263
1071
  case "com.amazonaws.managedblockchain#InvalidRequestException":
1264
- response = {
1265
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
1266
- name: errorCode,
1267
- $metadata: deserializeMetadata(output),
1268
- };
1269
- break;
1072
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
1270
1073
  case "ResourceNotFoundException":
1271
1074
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
1272
- response = {
1273
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1274
- name: errorCode,
1275
- $metadata: deserializeMetadata(output),
1276
- };
1277
- break;
1075
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
1278
1076
  case "ResourceNotReadyException":
1279
1077
  case "com.amazonaws.managedblockchain#ResourceNotReadyException":
1280
- response = {
1281
- ...(await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context)),
1282
- name: errorCode,
1283
- $metadata: deserializeMetadata(output),
1284
- };
1285
- break;
1078
+ throw await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context);
1286
1079
  case "ThrottlingException":
1287
1080
  case "com.amazonaws.managedblockchain#ThrottlingException":
1288
- response = {
1289
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
1290
- name: errorCode,
1291
- $metadata: deserializeMetadata(output),
1292
- };
1293
- break;
1081
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
1294
1082
  default:
1295
1083
  const parsedBody = parsedOutput.body;
1296
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1297
- response = {
1298
- ...parsedBody,
1299
- name: `${errorCode}`,
1300
- message: parsedBody.message || parsedBody.Message || errorCode,
1084
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1085
+ name: parsedBody.code || parsedBody.Code || errorCode,
1301
1086
  $fault: "client",
1302
1087
  $metadata: deserializeMetadata(output),
1303
- };
1088
+ });
1089
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1304
1090
  }
1305
- const message = response.message || response.Message || errorCode;
1306
- response.message = message;
1307
- delete response.Message;
1308
- return Promise.reject(Object.assign(new Error(message), response));
1309
1091
  };
1310
1092
  const deserializeAws_restJson1DeleteNodeCommand = async (output, context) => {
1311
1093
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1329,67 +1111,31 @@ const deserializeAws_restJson1DeleteNodeCommandError = async (output, context) =
1329
1111
  switch (errorCode) {
1330
1112
  case "AccessDeniedException":
1331
1113
  case "com.amazonaws.managedblockchain#AccessDeniedException":
1332
- response = {
1333
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
1334
- name: errorCode,
1335
- $metadata: deserializeMetadata(output),
1336
- };
1337
- break;
1114
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
1338
1115
  case "InternalServiceErrorException":
1339
1116
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
1340
- response = {
1341
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
1342
- name: errorCode,
1343
- $metadata: deserializeMetadata(output),
1344
- };
1345
- break;
1117
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
1346
1118
  case "InvalidRequestException":
1347
1119
  case "com.amazonaws.managedblockchain#InvalidRequestException":
1348
- response = {
1349
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
1350
- name: errorCode,
1351
- $metadata: deserializeMetadata(output),
1352
- };
1353
- break;
1120
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
1354
1121
  case "ResourceNotFoundException":
1355
1122
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
1356
- response = {
1357
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1358
- name: errorCode,
1359
- $metadata: deserializeMetadata(output),
1360
- };
1361
- break;
1123
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
1362
1124
  case "ResourceNotReadyException":
1363
1125
  case "com.amazonaws.managedblockchain#ResourceNotReadyException":
1364
- response = {
1365
- ...(await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context)),
1366
- name: errorCode,
1367
- $metadata: deserializeMetadata(output),
1368
- };
1369
- break;
1126
+ throw await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context);
1370
1127
  case "ThrottlingException":
1371
1128
  case "com.amazonaws.managedblockchain#ThrottlingException":
1372
- response = {
1373
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
1374
- name: errorCode,
1375
- $metadata: deserializeMetadata(output),
1376
- };
1377
- break;
1129
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
1378
1130
  default:
1379
1131
  const parsedBody = parsedOutput.body;
1380
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1381
- response = {
1382
- ...parsedBody,
1383
- name: `${errorCode}`,
1384
- message: parsedBody.message || parsedBody.Message || errorCode,
1132
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1133
+ name: parsedBody.code || parsedBody.Code || errorCode,
1385
1134
  $fault: "client",
1386
1135
  $metadata: deserializeMetadata(output),
1387
- };
1136
+ });
1137
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1388
1138
  }
1389
- const message = response.message || response.Message || errorCode;
1390
- response.message = message;
1391
- delete response.Message;
1392
- return Promise.reject(Object.assign(new Error(message), response));
1393
1139
  };
1394
1140
  const deserializeAws_restJson1GetMemberCommand = async (output, context) => {
1395
1141
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1417,59 +1163,28 @@ const deserializeAws_restJson1GetMemberCommandError = async (output, context) =>
1417
1163
  switch (errorCode) {
1418
1164
  case "AccessDeniedException":
1419
1165
  case "com.amazonaws.managedblockchain#AccessDeniedException":
1420
- response = {
1421
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
1422
- name: errorCode,
1423
- $metadata: deserializeMetadata(output),
1424
- };
1425
- break;
1166
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
1426
1167
  case "InternalServiceErrorException":
1427
1168
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
1428
- response = {
1429
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
1430
- name: errorCode,
1431
- $metadata: deserializeMetadata(output),
1432
- };
1433
- break;
1169
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
1434
1170
  case "InvalidRequestException":
1435
1171
  case "com.amazonaws.managedblockchain#InvalidRequestException":
1436
- response = {
1437
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
1438
- name: errorCode,
1439
- $metadata: deserializeMetadata(output),
1440
- };
1441
- break;
1172
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
1442
1173
  case "ResourceNotFoundException":
1443
1174
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
1444
- response = {
1445
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1446
- name: errorCode,
1447
- $metadata: deserializeMetadata(output),
1448
- };
1449
- break;
1175
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
1450
1176
  case "ThrottlingException":
1451
1177
  case "com.amazonaws.managedblockchain#ThrottlingException":
1452
- response = {
1453
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
1454
- name: errorCode,
1455
- $metadata: deserializeMetadata(output),
1456
- };
1457
- break;
1178
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
1458
1179
  default:
1459
1180
  const parsedBody = parsedOutput.body;
1460
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1461
- response = {
1462
- ...parsedBody,
1463
- name: `${errorCode}`,
1464
- message: parsedBody.message || parsedBody.Message || errorCode,
1181
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1182
+ name: parsedBody.code || parsedBody.Code || errorCode,
1465
1183
  $fault: "client",
1466
1184
  $metadata: deserializeMetadata(output),
1467
- };
1185
+ });
1186
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1468
1187
  }
1469
- const message = response.message || response.Message || errorCode;
1470
- response.message = message;
1471
- delete response.Message;
1472
- return Promise.reject(Object.assign(new Error(message), response));
1473
1188
  };
1474
1189
  const deserializeAws_restJson1GetNetworkCommand = async (output, context) => {
1475
1190
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1497,59 +1212,28 @@ const deserializeAws_restJson1GetNetworkCommandError = async (output, context) =
1497
1212
  switch (errorCode) {
1498
1213
  case "AccessDeniedException":
1499
1214
  case "com.amazonaws.managedblockchain#AccessDeniedException":
1500
- response = {
1501
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
1502
- name: errorCode,
1503
- $metadata: deserializeMetadata(output),
1504
- };
1505
- break;
1215
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
1506
1216
  case "InternalServiceErrorException":
1507
1217
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
1508
- response = {
1509
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
1510
- name: errorCode,
1511
- $metadata: deserializeMetadata(output),
1512
- };
1513
- break;
1218
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
1514
1219
  case "InvalidRequestException":
1515
1220
  case "com.amazonaws.managedblockchain#InvalidRequestException":
1516
- response = {
1517
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
1518
- name: errorCode,
1519
- $metadata: deserializeMetadata(output),
1520
- };
1521
- break;
1221
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
1522
1222
  case "ResourceNotFoundException":
1523
1223
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
1524
- response = {
1525
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1526
- name: errorCode,
1527
- $metadata: deserializeMetadata(output),
1528
- };
1529
- break;
1224
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
1530
1225
  case "ThrottlingException":
1531
1226
  case "com.amazonaws.managedblockchain#ThrottlingException":
1532
- response = {
1533
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
1534
- name: errorCode,
1535
- $metadata: deserializeMetadata(output),
1536
- };
1537
- break;
1227
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
1538
1228
  default:
1539
1229
  const parsedBody = parsedOutput.body;
1540
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1541
- response = {
1542
- ...parsedBody,
1543
- name: `${errorCode}`,
1544
- message: parsedBody.message || parsedBody.Message || errorCode,
1230
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1231
+ name: parsedBody.code || parsedBody.Code || errorCode,
1545
1232
  $fault: "client",
1546
1233
  $metadata: deserializeMetadata(output),
1547
- };
1234
+ });
1235
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1548
1236
  }
1549
- const message = response.message || response.Message || errorCode;
1550
- response.message = message;
1551
- delete response.Message;
1552
- return Promise.reject(Object.assign(new Error(message), response));
1553
1237
  };
1554
1238
  const deserializeAws_restJson1GetNodeCommand = async (output, context) => {
1555
1239
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1577,59 +1261,28 @@ const deserializeAws_restJson1GetNodeCommandError = async (output, context) => {
1577
1261
  switch (errorCode) {
1578
1262
  case "AccessDeniedException":
1579
1263
  case "com.amazonaws.managedblockchain#AccessDeniedException":
1580
- response = {
1581
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
1582
- name: errorCode,
1583
- $metadata: deserializeMetadata(output),
1584
- };
1585
- break;
1264
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
1586
1265
  case "InternalServiceErrorException":
1587
1266
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
1588
- response = {
1589
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
1590
- name: errorCode,
1591
- $metadata: deserializeMetadata(output),
1592
- };
1593
- break;
1267
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
1594
1268
  case "InvalidRequestException":
1595
1269
  case "com.amazonaws.managedblockchain#InvalidRequestException":
1596
- response = {
1597
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
1598
- name: errorCode,
1599
- $metadata: deserializeMetadata(output),
1600
- };
1601
- break;
1270
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
1602
1271
  case "ResourceNotFoundException":
1603
1272
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
1604
- response = {
1605
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1606
- name: errorCode,
1607
- $metadata: deserializeMetadata(output),
1608
- };
1609
- break;
1273
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
1610
1274
  case "ThrottlingException":
1611
1275
  case "com.amazonaws.managedblockchain#ThrottlingException":
1612
- response = {
1613
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
1614
- name: errorCode,
1615
- $metadata: deserializeMetadata(output),
1616
- };
1617
- break;
1276
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
1618
1277
  default:
1619
1278
  const parsedBody = parsedOutput.body;
1620
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1621
- response = {
1622
- ...parsedBody,
1623
- name: `${errorCode}`,
1624
- message: parsedBody.message || parsedBody.Message || errorCode,
1279
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1280
+ name: parsedBody.code || parsedBody.Code || errorCode,
1625
1281
  $fault: "client",
1626
1282
  $metadata: deserializeMetadata(output),
1627
- };
1283
+ });
1284
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1628
1285
  }
1629
- const message = response.message || response.Message || errorCode;
1630
- response.message = message;
1631
- delete response.Message;
1632
- return Promise.reject(Object.assign(new Error(message), response));
1633
1286
  };
1634
1287
  const deserializeAws_restJson1GetProposalCommand = async (output, context) => {
1635
1288
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1657,59 +1310,28 @@ const deserializeAws_restJson1GetProposalCommandError = async (output, context)
1657
1310
  switch (errorCode) {
1658
1311
  case "AccessDeniedException":
1659
1312
  case "com.amazonaws.managedblockchain#AccessDeniedException":
1660
- response = {
1661
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
1662
- name: errorCode,
1663
- $metadata: deserializeMetadata(output),
1664
- };
1665
- break;
1313
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
1666
1314
  case "InternalServiceErrorException":
1667
1315
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
1668
- response = {
1669
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
1670
- name: errorCode,
1671
- $metadata: deserializeMetadata(output),
1672
- };
1673
- break;
1316
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
1674
1317
  case "InvalidRequestException":
1675
1318
  case "com.amazonaws.managedblockchain#InvalidRequestException":
1676
- response = {
1677
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
1678
- name: errorCode,
1679
- $metadata: deserializeMetadata(output),
1680
- };
1681
- break;
1319
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
1682
1320
  case "ResourceNotFoundException":
1683
1321
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
1684
- response = {
1685
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1686
- name: errorCode,
1687
- $metadata: deserializeMetadata(output),
1688
- };
1689
- break;
1322
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
1690
1323
  case "ThrottlingException":
1691
1324
  case "com.amazonaws.managedblockchain#ThrottlingException":
1692
- response = {
1693
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
1694
- name: errorCode,
1695
- $metadata: deserializeMetadata(output),
1696
- };
1697
- break;
1325
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
1698
1326
  default:
1699
1327
  const parsedBody = parsedOutput.body;
1700
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1701
- response = {
1702
- ...parsedBody,
1703
- name: `${errorCode}`,
1704
- message: parsedBody.message || parsedBody.Message || errorCode,
1328
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1329
+ name: parsedBody.code || parsedBody.Code || errorCode,
1705
1330
  $fault: "client",
1706
1331
  $metadata: deserializeMetadata(output),
1707
- };
1332
+ });
1333
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1708
1334
  }
1709
- const message = response.message || response.Message || errorCode;
1710
- response.message = message;
1711
- delete response.Message;
1712
- return Promise.reject(Object.assign(new Error(message), response));
1713
1335
  };
1714
1336
  const deserializeAws_restJson1ListInvitationsCommand = async (output, context) => {
1715
1337
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1741,67 +1363,31 @@ const deserializeAws_restJson1ListInvitationsCommandError = async (output, conte
1741
1363
  switch (errorCode) {
1742
1364
  case "AccessDeniedException":
1743
1365
  case "com.amazonaws.managedblockchain#AccessDeniedException":
1744
- response = {
1745
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
1746
- name: errorCode,
1747
- $metadata: deserializeMetadata(output),
1748
- };
1749
- break;
1366
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
1750
1367
  case "InternalServiceErrorException":
1751
1368
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
1752
- response = {
1753
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
1754
- name: errorCode,
1755
- $metadata: deserializeMetadata(output),
1756
- };
1757
- break;
1369
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
1758
1370
  case "InvalidRequestException":
1759
1371
  case "com.amazonaws.managedblockchain#InvalidRequestException":
1760
- response = {
1761
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
1762
- name: errorCode,
1763
- $metadata: deserializeMetadata(output),
1764
- };
1765
- break;
1372
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
1766
1373
  case "ResourceLimitExceededException":
1767
1374
  case "com.amazonaws.managedblockchain#ResourceLimitExceededException":
1768
- response = {
1769
- ...(await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context)),
1770
- name: errorCode,
1771
- $metadata: deserializeMetadata(output),
1772
- };
1773
- break;
1375
+ throw await deserializeAws_restJson1ResourceLimitExceededExceptionResponse(parsedOutput, context);
1774
1376
  case "ResourceNotFoundException":
1775
1377
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
1776
- response = {
1777
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
1778
- name: errorCode,
1779
- $metadata: deserializeMetadata(output),
1780
- };
1781
- break;
1378
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
1782
1379
  case "ThrottlingException":
1783
1380
  case "com.amazonaws.managedblockchain#ThrottlingException":
1784
- response = {
1785
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
1786
- name: errorCode,
1787
- $metadata: deserializeMetadata(output),
1788
- };
1789
- break;
1381
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
1790
1382
  default:
1791
1383
  const parsedBody = parsedOutput.body;
1792
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1793
- response = {
1794
- ...parsedBody,
1795
- name: `${errorCode}`,
1796
- message: parsedBody.message || parsedBody.Message || errorCode,
1384
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1385
+ name: parsedBody.code || parsedBody.Code || errorCode,
1797
1386
  $fault: "client",
1798
1387
  $metadata: deserializeMetadata(output),
1799
- };
1388
+ });
1389
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1800
1390
  }
1801
- const message = response.message || response.Message || errorCode;
1802
- response.message = message;
1803
- delete response.Message;
1804
- return Promise.reject(Object.assign(new Error(message), response));
1805
1391
  };
1806
1392
  const deserializeAws_restJson1ListMembersCommand = async (output, context) => {
1807
1393
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1833,51 +1419,25 @@ const deserializeAws_restJson1ListMembersCommandError = async (output, context)
1833
1419
  switch (errorCode) {
1834
1420
  case "AccessDeniedException":
1835
1421
  case "com.amazonaws.managedblockchain#AccessDeniedException":
1836
- response = {
1837
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
1838
- name: errorCode,
1839
- $metadata: deserializeMetadata(output),
1840
- };
1841
- break;
1422
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
1842
1423
  case "InternalServiceErrorException":
1843
1424
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
1844
- response = {
1845
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
1846
- name: errorCode,
1847
- $metadata: deserializeMetadata(output),
1848
- };
1849
- break;
1425
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
1850
1426
  case "InvalidRequestException":
1851
1427
  case "com.amazonaws.managedblockchain#InvalidRequestException":
1852
- response = {
1853
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
1854
- name: errorCode,
1855
- $metadata: deserializeMetadata(output),
1856
- };
1857
- break;
1428
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
1858
1429
  case "ThrottlingException":
1859
1430
  case "com.amazonaws.managedblockchain#ThrottlingException":
1860
- response = {
1861
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
1862
- name: errorCode,
1863
- $metadata: deserializeMetadata(output),
1864
- };
1865
- break;
1431
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
1866
1432
  default:
1867
1433
  const parsedBody = parsedOutput.body;
1868
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1869
- response = {
1870
- ...parsedBody,
1871
- name: `${errorCode}`,
1872
- message: parsedBody.message || parsedBody.Message || errorCode,
1434
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1435
+ name: parsedBody.code || parsedBody.Code || errorCode,
1873
1436
  $fault: "client",
1874
1437
  $metadata: deserializeMetadata(output),
1875
- };
1438
+ });
1439
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1876
1440
  }
1877
- const message = response.message || response.Message || errorCode;
1878
- response.message = message;
1879
- delete response.Message;
1880
- return Promise.reject(Object.assign(new Error(message), response));
1881
1441
  };
1882
1442
  const deserializeAws_restJson1ListNetworksCommand = async (output, context) => {
1883
1443
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1909,51 +1469,25 @@ const deserializeAws_restJson1ListNetworksCommandError = async (output, context)
1909
1469
  switch (errorCode) {
1910
1470
  case "AccessDeniedException":
1911
1471
  case "com.amazonaws.managedblockchain#AccessDeniedException":
1912
- response = {
1913
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
1914
- name: errorCode,
1915
- $metadata: deserializeMetadata(output),
1916
- };
1917
- break;
1472
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
1918
1473
  case "InternalServiceErrorException":
1919
1474
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
1920
- response = {
1921
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
1922
- name: errorCode,
1923
- $metadata: deserializeMetadata(output),
1924
- };
1925
- break;
1475
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
1926
1476
  case "InvalidRequestException":
1927
1477
  case "com.amazonaws.managedblockchain#InvalidRequestException":
1928
- response = {
1929
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
1930
- name: errorCode,
1931
- $metadata: deserializeMetadata(output),
1932
- };
1933
- break;
1478
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
1934
1479
  case "ThrottlingException":
1935
1480
  case "com.amazonaws.managedblockchain#ThrottlingException":
1936
- response = {
1937
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
1938
- name: errorCode,
1939
- $metadata: deserializeMetadata(output),
1940
- };
1941
- break;
1481
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
1942
1482
  default:
1943
1483
  const parsedBody = parsedOutput.body;
1944
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
1945
- response = {
1946
- ...parsedBody,
1947
- name: `${errorCode}`,
1948
- message: parsedBody.message || parsedBody.Message || errorCode,
1484
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1485
+ name: parsedBody.code || parsedBody.Code || errorCode,
1949
1486
  $fault: "client",
1950
1487
  $metadata: deserializeMetadata(output),
1951
- };
1488
+ });
1489
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
1952
1490
  }
1953
- const message = response.message || response.Message || errorCode;
1954
- response.message = message;
1955
- delete response.Message;
1956
- return Promise.reject(Object.assign(new Error(message), response));
1957
1491
  };
1958
1492
  const deserializeAws_restJson1ListNodesCommand = async (output, context) => {
1959
1493
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -1985,51 +1519,25 @@ const deserializeAws_restJson1ListNodesCommandError = async (output, context) =>
1985
1519
  switch (errorCode) {
1986
1520
  case "AccessDeniedException":
1987
1521
  case "com.amazonaws.managedblockchain#AccessDeniedException":
1988
- response = {
1989
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
1990
- name: errorCode,
1991
- $metadata: deserializeMetadata(output),
1992
- };
1993
- break;
1522
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
1994
1523
  case "InternalServiceErrorException":
1995
1524
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
1996
- response = {
1997
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
1998
- name: errorCode,
1999
- $metadata: deserializeMetadata(output),
2000
- };
2001
- break;
1525
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
2002
1526
  case "InvalidRequestException":
2003
1527
  case "com.amazonaws.managedblockchain#InvalidRequestException":
2004
- response = {
2005
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
2006
- name: errorCode,
2007
- $metadata: deserializeMetadata(output),
2008
- };
2009
- break;
1528
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
2010
1529
  case "ThrottlingException":
2011
1530
  case "com.amazonaws.managedblockchain#ThrottlingException":
2012
- response = {
2013
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
2014
- name: errorCode,
2015
- $metadata: deserializeMetadata(output),
2016
- };
2017
- break;
1531
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
2018
1532
  default:
2019
1533
  const parsedBody = parsedOutput.body;
2020
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2021
- response = {
2022
- ...parsedBody,
2023
- name: `${errorCode}`,
2024
- message: parsedBody.message || parsedBody.Message || errorCode,
1534
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1535
+ name: parsedBody.code || parsedBody.Code || errorCode,
2025
1536
  $fault: "client",
2026
1537
  $metadata: deserializeMetadata(output),
2027
- };
1538
+ });
1539
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2028
1540
  }
2029
- const message = response.message || response.Message || errorCode;
2030
- response.message = message;
2031
- delete response.Message;
2032
- return Promise.reject(Object.assign(new Error(message), response));
2033
1541
  };
2034
1542
  const deserializeAws_restJson1ListProposalsCommand = async (output, context) => {
2035
1543
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -2061,59 +1569,28 @@ const deserializeAws_restJson1ListProposalsCommandError = async (output, context
2061
1569
  switch (errorCode) {
2062
1570
  case "AccessDeniedException":
2063
1571
  case "com.amazonaws.managedblockchain#AccessDeniedException":
2064
- response = {
2065
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
2066
- name: errorCode,
2067
- $metadata: deserializeMetadata(output),
2068
- };
2069
- break;
1572
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
2070
1573
  case "InternalServiceErrorException":
2071
1574
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
2072
- response = {
2073
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
2074
- name: errorCode,
2075
- $metadata: deserializeMetadata(output),
2076
- };
2077
- break;
1575
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
2078
1576
  case "InvalidRequestException":
2079
1577
  case "com.amazonaws.managedblockchain#InvalidRequestException":
2080
- response = {
2081
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
2082
- name: errorCode,
2083
- $metadata: deserializeMetadata(output),
2084
- };
2085
- break;
1578
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
2086
1579
  case "ResourceNotFoundException":
2087
1580
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
2088
- response = {
2089
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
2090
- name: errorCode,
2091
- $metadata: deserializeMetadata(output),
2092
- };
2093
- break;
1581
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
2094
1582
  case "ThrottlingException":
2095
1583
  case "com.amazonaws.managedblockchain#ThrottlingException":
2096
- response = {
2097
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
2098
- name: errorCode,
2099
- $metadata: deserializeMetadata(output),
2100
- };
2101
- break;
1584
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
2102
1585
  default:
2103
1586
  const parsedBody = parsedOutput.body;
2104
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2105
- response = {
2106
- ...parsedBody,
2107
- name: `${errorCode}`,
2108
- message: parsedBody.message || parsedBody.Message || errorCode,
1587
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1588
+ name: parsedBody.code || parsedBody.Code || errorCode,
2109
1589
  $fault: "client",
2110
1590
  $metadata: deserializeMetadata(output),
2111
- };
1591
+ });
1592
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2112
1593
  }
2113
- const message = response.message || response.Message || errorCode;
2114
- response.message = message;
2115
- delete response.Message;
2116
- return Promise.reject(Object.assign(new Error(message), response));
2117
1594
  };
2118
1595
  const deserializeAws_restJson1ListProposalVotesCommand = async (output, context) => {
2119
1596
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -2145,51 +1622,25 @@ const deserializeAws_restJson1ListProposalVotesCommandError = async (output, con
2145
1622
  switch (errorCode) {
2146
1623
  case "AccessDeniedException":
2147
1624
  case "com.amazonaws.managedblockchain#AccessDeniedException":
2148
- response = {
2149
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
2150
- name: errorCode,
2151
- $metadata: deserializeMetadata(output),
2152
- };
2153
- break;
1625
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
2154
1626
  case "InternalServiceErrorException":
2155
1627
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
2156
- response = {
2157
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
2158
- name: errorCode,
2159
- $metadata: deserializeMetadata(output),
2160
- };
2161
- break;
1628
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
2162
1629
  case "InvalidRequestException":
2163
1630
  case "com.amazonaws.managedblockchain#InvalidRequestException":
2164
- response = {
2165
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
2166
- name: errorCode,
2167
- $metadata: deserializeMetadata(output),
2168
- };
2169
- break;
1631
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
2170
1632
  case "ThrottlingException":
2171
1633
  case "com.amazonaws.managedblockchain#ThrottlingException":
2172
- response = {
2173
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
2174
- name: errorCode,
2175
- $metadata: deserializeMetadata(output),
2176
- };
2177
- break;
1634
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
2178
1635
  default:
2179
1636
  const parsedBody = parsedOutput.body;
2180
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2181
- response = {
2182
- ...parsedBody,
2183
- name: `${errorCode}`,
2184
- message: parsedBody.message || parsedBody.Message || errorCode,
1637
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1638
+ name: parsedBody.code || parsedBody.Code || errorCode,
2185
1639
  $fault: "client",
2186
1640
  $metadata: deserializeMetadata(output),
2187
- };
1641
+ });
1642
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2188
1643
  }
2189
- const message = response.message || response.Message || errorCode;
2190
- response.message = message;
2191
- delete response.Message;
2192
- return Promise.reject(Object.assign(new Error(message), response));
2193
1644
  };
2194
1645
  const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
2195
1646
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -2217,51 +1668,25 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
2217
1668
  switch (errorCode) {
2218
1669
  case "InternalServiceErrorException":
2219
1670
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
2220
- response = {
2221
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
2222
- name: errorCode,
2223
- $metadata: deserializeMetadata(output),
2224
- };
2225
- break;
1671
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
2226
1672
  case "InvalidRequestException":
2227
1673
  case "com.amazonaws.managedblockchain#InvalidRequestException":
2228
- response = {
2229
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
2230
- name: errorCode,
2231
- $metadata: deserializeMetadata(output),
2232
- };
2233
- break;
1674
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
2234
1675
  case "ResourceNotFoundException":
2235
1676
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
2236
- response = {
2237
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
2238
- name: errorCode,
2239
- $metadata: deserializeMetadata(output),
2240
- };
2241
- break;
1677
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
2242
1678
  case "ResourceNotReadyException":
2243
1679
  case "com.amazonaws.managedblockchain#ResourceNotReadyException":
2244
- response = {
2245
- ...(await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context)),
2246
- name: errorCode,
2247
- $metadata: deserializeMetadata(output),
2248
- };
2249
- break;
1680
+ throw await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context);
2250
1681
  default:
2251
1682
  const parsedBody = parsedOutput.body;
2252
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2253
- response = {
2254
- ...parsedBody,
2255
- name: `${errorCode}`,
2256
- message: parsedBody.message || parsedBody.Message || errorCode,
1683
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1684
+ name: parsedBody.code || parsedBody.Code || errorCode,
2257
1685
  $fault: "client",
2258
1686
  $metadata: deserializeMetadata(output),
2259
- };
1687
+ });
1688
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2260
1689
  }
2261
- const message = response.message || response.Message || errorCode;
2262
- response.message = message;
2263
- delete response.Message;
2264
- return Promise.reject(Object.assign(new Error(message), response));
2265
1690
  };
2266
1691
  const deserializeAws_restJson1RejectInvitationCommand = async (output, context) => {
2267
1692
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -2285,67 +1710,31 @@ const deserializeAws_restJson1RejectInvitationCommandError = async (output, cont
2285
1710
  switch (errorCode) {
2286
1711
  case "AccessDeniedException":
2287
1712
  case "com.amazonaws.managedblockchain#AccessDeniedException":
2288
- response = {
2289
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
2290
- name: errorCode,
2291
- $metadata: deserializeMetadata(output),
2292
- };
2293
- break;
1713
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
2294
1714
  case "IllegalActionException":
2295
1715
  case "com.amazonaws.managedblockchain#IllegalActionException":
2296
- response = {
2297
- ...(await deserializeAws_restJson1IllegalActionExceptionResponse(parsedOutput, context)),
2298
- name: errorCode,
2299
- $metadata: deserializeMetadata(output),
2300
- };
2301
- break;
1716
+ throw await deserializeAws_restJson1IllegalActionExceptionResponse(parsedOutput, context);
2302
1717
  case "InternalServiceErrorException":
2303
1718
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
2304
- response = {
2305
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
2306
- name: errorCode,
2307
- $metadata: deserializeMetadata(output),
2308
- };
2309
- break;
1719
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
2310
1720
  case "InvalidRequestException":
2311
1721
  case "com.amazonaws.managedblockchain#InvalidRequestException":
2312
- response = {
2313
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
2314
- name: errorCode,
2315
- $metadata: deserializeMetadata(output),
2316
- };
2317
- break;
1722
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
2318
1723
  case "ResourceNotFoundException":
2319
1724
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
2320
- response = {
2321
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
2322
- name: errorCode,
2323
- $metadata: deserializeMetadata(output),
2324
- };
2325
- break;
1725
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
2326
1726
  case "ThrottlingException":
2327
1727
  case "com.amazonaws.managedblockchain#ThrottlingException":
2328
- response = {
2329
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
2330
- name: errorCode,
2331
- $metadata: deserializeMetadata(output),
2332
- };
2333
- break;
1728
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
2334
1729
  default:
2335
1730
  const parsedBody = parsedOutput.body;
2336
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2337
- response = {
2338
- ...parsedBody,
2339
- name: `${errorCode}`,
2340
- message: parsedBody.message || parsedBody.Message || errorCode,
1731
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1732
+ name: parsedBody.code || parsedBody.Code || errorCode,
2341
1733
  $fault: "client",
2342
1734
  $metadata: deserializeMetadata(output),
2343
- };
1735
+ });
1736
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2344
1737
  }
2345
- const message = response.message || response.Message || errorCode;
2346
- response.message = message;
2347
- delete response.Message;
2348
- return Promise.reject(Object.assign(new Error(message), response));
2349
1738
  };
2350
1739
  const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
2351
1740
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -2369,59 +1758,28 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
2369
1758
  switch (errorCode) {
2370
1759
  case "InternalServiceErrorException":
2371
1760
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
2372
- response = {
2373
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
2374
- name: errorCode,
2375
- $metadata: deserializeMetadata(output),
2376
- };
2377
- break;
1761
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
2378
1762
  case "InvalidRequestException":
2379
1763
  case "com.amazonaws.managedblockchain#InvalidRequestException":
2380
- response = {
2381
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
2382
- name: errorCode,
2383
- $metadata: deserializeMetadata(output),
2384
- };
2385
- break;
1764
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
2386
1765
  case "ResourceNotFoundException":
2387
1766
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
2388
- response = {
2389
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
2390
- name: errorCode,
2391
- $metadata: deserializeMetadata(output),
2392
- };
2393
- break;
1767
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
2394
1768
  case "ResourceNotReadyException":
2395
1769
  case "com.amazonaws.managedblockchain#ResourceNotReadyException":
2396
- response = {
2397
- ...(await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context)),
2398
- name: errorCode,
2399
- $metadata: deserializeMetadata(output),
2400
- };
2401
- break;
1770
+ throw await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context);
2402
1771
  case "TooManyTagsException":
2403
1772
  case "com.amazonaws.managedblockchain#TooManyTagsException":
2404
- response = {
2405
- ...(await deserializeAws_restJson1TooManyTagsExceptionResponse(parsedOutput, context)),
2406
- name: errorCode,
2407
- $metadata: deserializeMetadata(output),
2408
- };
2409
- break;
1773
+ throw await deserializeAws_restJson1TooManyTagsExceptionResponse(parsedOutput, context);
2410
1774
  default:
2411
1775
  const parsedBody = parsedOutput.body;
2412
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2413
- response = {
2414
- ...parsedBody,
2415
- name: `${errorCode}`,
2416
- message: parsedBody.message || parsedBody.Message || errorCode,
1776
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1777
+ name: parsedBody.code || parsedBody.Code || errorCode,
2417
1778
  $fault: "client",
2418
1779
  $metadata: deserializeMetadata(output),
2419
- };
1780
+ });
1781
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2420
1782
  }
2421
- const message = response.message || response.Message || errorCode;
2422
- response.message = message;
2423
- delete response.Message;
2424
- return Promise.reject(Object.assign(new Error(message), response));
2425
1783
  };
2426
1784
  const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
2427
1785
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -2445,51 +1803,25 @@ const deserializeAws_restJson1UntagResourceCommandError = async (output, context
2445
1803
  switch (errorCode) {
2446
1804
  case "InternalServiceErrorException":
2447
1805
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
2448
- response = {
2449
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
2450
- name: errorCode,
2451
- $metadata: deserializeMetadata(output),
2452
- };
2453
- break;
1806
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
2454
1807
  case "InvalidRequestException":
2455
1808
  case "com.amazonaws.managedblockchain#InvalidRequestException":
2456
- response = {
2457
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
2458
- name: errorCode,
2459
- $metadata: deserializeMetadata(output),
2460
- };
2461
- break;
1809
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
2462
1810
  case "ResourceNotFoundException":
2463
1811
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
2464
- response = {
2465
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
2466
- name: errorCode,
2467
- $metadata: deserializeMetadata(output),
2468
- };
2469
- break;
1812
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
2470
1813
  case "ResourceNotReadyException":
2471
1814
  case "com.amazonaws.managedblockchain#ResourceNotReadyException":
2472
- response = {
2473
- ...(await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context)),
2474
- name: errorCode,
2475
- $metadata: deserializeMetadata(output),
2476
- };
2477
- break;
1815
+ throw await deserializeAws_restJson1ResourceNotReadyExceptionResponse(parsedOutput, context);
2478
1816
  default:
2479
1817
  const parsedBody = parsedOutput.body;
2480
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2481
- response = {
2482
- ...parsedBody,
2483
- name: `${errorCode}`,
2484
- message: parsedBody.message || parsedBody.Message || errorCode,
1818
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1819
+ name: parsedBody.code || parsedBody.Code || errorCode,
2485
1820
  $fault: "client",
2486
1821
  $metadata: deserializeMetadata(output),
2487
- };
1822
+ });
1823
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2488
1824
  }
2489
- const message = response.message || response.Message || errorCode;
2490
- response.message = message;
2491
- delete response.Message;
2492
- return Promise.reject(Object.assign(new Error(message), response));
2493
1825
  };
2494
1826
  const deserializeAws_restJson1UpdateMemberCommand = async (output, context) => {
2495
1827
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -2513,59 +1845,28 @@ const deserializeAws_restJson1UpdateMemberCommandError = async (output, context)
2513
1845
  switch (errorCode) {
2514
1846
  case "AccessDeniedException":
2515
1847
  case "com.amazonaws.managedblockchain#AccessDeniedException":
2516
- response = {
2517
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
2518
- name: errorCode,
2519
- $metadata: deserializeMetadata(output),
2520
- };
2521
- break;
1848
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
2522
1849
  case "InternalServiceErrorException":
2523
1850
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
2524
- response = {
2525
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
2526
- name: errorCode,
2527
- $metadata: deserializeMetadata(output),
2528
- };
2529
- break;
1851
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
2530
1852
  case "InvalidRequestException":
2531
1853
  case "com.amazonaws.managedblockchain#InvalidRequestException":
2532
- response = {
2533
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
2534
- name: errorCode,
2535
- $metadata: deserializeMetadata(output),
2536
- };
2537
- break;
1854
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
2538
1855
  case "ResourceNotFoundException":
2539
1856
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
2540
- response = {
2541
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
2542
- name: errorCode,
2543
- $metadata: deserializeMetadata(output),
2544
- };
2545
- break;
1857
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
2546
1858
  case "ThrottlingException":
2547
1859
  case "com.amazonaws.managedblockchain#ThrottlingException":
2548
- response = {
2549
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
2550
- name: errorCode,
2551
- $metadata: deserializeMetadata(output),
2552
- };
2553
- break;
1860
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
2554
1861
  default:
2555
1862
  const parsedBody = parsedOutput.body;
2556
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2557
- response = {
2558
- ...parsedBody,
2559
- name: `${errorCode}`,
2560
- message: parsedBody.message || parsedBody.Message || errorCode,
1863
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1864
+ name: parsedBody.code || parsedBody.Code || errorCode,
2561
1865
  $fault: "client",
2562
1866
  $metadata: deserializeMetadata(output),
2563
- };
1867
+ });
1868
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2564
1869
  }
2565
- const message = response.message || response.Message || errorCode;
2566
- response.message = message;
2567
- delete response.Message;
2568
- return Promise.reject(Object.assign(new Error(message), response));
2569
1870
  };
2570
1871
  const deserializeAws_restJson1UpdateNodeCommand = async (output, context) => {
2571
1872
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -2589,59 +1890,28 @@ const deserializeAws_restJson1UpdateNodeCommandError = async (output, context) =
2589
1890
  switch (errorCode) {
2590
1891
  case "AccessDeniedException":
2591
1892
  case "com.amazonaws.managedblockchain#AccessDeniedException":
2592
- response = {
2593
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
2594
- name: errorCode,
2595
- $metadata: deserializeMetadata(output),
2596
- };
2597
- break;
1893
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
2598
1894
  case "InternalServiceErrorException":
2599
1895
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
2600
- response = {
2601
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
2602
- name: errorCode,
2603
- $metadata: deserializeMetadata(output),
2604
- };
2605
- break;
1896
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
2606
1897
  case "InvalidRequestException":
2607
1898
  case "com.amazonaws.managedblockchain#InvalidRequestException":
2608
- response = {
2609
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
2610
- name: errorCode,
2611
- $metadata: deserializeMetadata(output),
2612
- };
2613
- break;
1899
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
2614
1900
  case "ResourceNotFoundException":
2615
1901
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
2616
- response = {
2617
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
2618
- name: errorCode,
2619
- $metadata: deserializeMetadata(output),
2620
- };
2621
- break;
1902
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
2622
1903
  case "ThrottlingException":
2623
1904
  case "com.amazonaws.managedblockchain#ThrottlingException":
2624
- response = {
2625
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
2626
- name: errorCode,
2627
- $metadata: deserializeMetadata(output),
2628
- };
2629
- break;
1905
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
2630
1906
  default:
2631
1907
  const parsedBody = parsedOutput.body;
2632
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2633
- response = {
2634
- ...parsedBody,
2635
- name: `${errorCode}`,
2636
- message: parsedBody.message || parsedBody.Message || errorCode,
1908
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1909
+ name: parsedBody.code || parsedBody.Code || errorCode,
2637
1910
  $fault: "client",
2638
1911
  $metadata: deserializeMetadata(output),
2639
- };
1912
+ });
1913
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2640
1914
  }
2641
- const message = response.message || response.Message || errorCode;
2642
- response.message = message;
2643
- delete response.Message;
2644
- return Promise.reject(Object.assign(new Error(message), response));
2645
1915
  };
2646
1916
  const deserializeAws_restJson1VoteOnProposalCommand = async (output, context) => {
2647
1917
  if (output.statusCode !== 200 && output.statusCode >= 300) {
@@ -2665,150 +1935,103 @@ const deserializeAws_restJson1VoteOnProposalCommandError = async (output, contex
2665
1935
  switch (errorCode) {
2666
1936
  case "AccessDeniedException":
2667
1937
  case "com.amazonaws.managedblockchain#AccessDeniedException":
2668
- response = {
2669
- ...(await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context)),
2670
- name: errorCode,
2671
- $metadata: deserializeMetadata(output),
2672
- };
2673
- break;
1938
+ throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
2674
1939
  case "IllegalActionException":
2675
1940
  case "com.amazonaws.managedblockchain#IllegalActionException":
2676
- response = {
2677
- ...(await deserializeAws_restJson1IllegalActionExceptionResponse(parsedOutput, context)),
2678
- name: errorCode,
2679
- $metadata: deserializeMetadata(output),
2680
- };
2681
- break;
1941
+ throw await deserializeAws_restJson1IllegalActionExceptionResponse(parsedOutput, context);
2682
1942
  case "InternalServiceErrorException":
2683
1943
  case "com.amazonaws.managedblockchain#InternalServiceErrorException":
2684
- response = {
2685
- ...(await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context)),
2686
- name: errorCode,
2687
- $metadata: deserializeMetadata(output),
2688
- };
2689
- break;
1944
+ throw await deserializeAws_restJson1InternalServiceErrorExceptionResponse(parsedOutput, context);
2690
1945
  case "InvalidRequestException":
2691
1946
  case "com.amazonaws.managedblockchain#InvalidRequestException":
2692
- response = {
2693
- ...(await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context)),
2694
- name: errorCode,
2695
- $metadata: deserializeMetadata(output),
2696
- };
2697
- break;
1947
+ throw await deserializeAws_restJson1InvalidRequestExceptionResponse(parsedOutput, context);
2698
1948
  case "ResourceNotFoundException":
2699
1949
  case "com.amazonaws.managedblockchain#ResourceNotFoundException":
2700
- response = {
2701
- ...(await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context)),
2702
- name: errorCode,
2703
- $metadata: deserializeMetadata(output),
2704
- };
2705
- break;
1950
+ throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
2706
1951
  case "ThrottlingException":
2707
1952
  case "com.amazonaws.managedblockchain#ThrottlingException":
2708
- response = {
2709
- ...(await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context)),
2710
- name: errorCode,
2711
- $metadata: deserializeMetadata(output),
2712
- };
2713
- break;
1953
+ throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
2714
1954
  default:
2715
1955
  const parsedBody = parsedOutput.body;
2716
- errorCode = parsedBody.code || parsedBody.Code || errorCode;
2717
- response = {
2718
- ...parsedBody,
2719
- name: `${errorCode}`,
2720
- message: parsedBody.message || parsedBody.Message || errorCode,
1956
+ response = new ManagedBlockchainServiceException_1.ManagedBlockchainServiceException({
1957
+ name: parsedBody.code || parsedBody.Code || errorCode,
2721
1958
  $fault: "client",
2722
1959
  $metadata: deserializeMetadata(output),
2723
- };
1960
+ });
1961
+ throw smithy_client_1.decorateServiceException(response, parsedBody);
2724
1962
  }
2725
- const message = response.message || response.Message || errorCode;
2726
- response.message = message;
2727
- delete response.Message;
2728
- return Promise.reject(Object.assign(new Error(message), response));
2729
1963
  };
2730
1964
  const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
2731
- const contents = {
2732
- name: "AccessDeniedException",
2733
- $fault: "client",
2734
- $metadata: deserializeMetadata(parsedOutput),
2735
- Message: undefined,
2736
- };
1965
+ const contents = {};
2737
1966
  const data = parsedOutput.body;
2738
1967
  if (data.Message !== undefined && data.Message !== null) {
2739
1968
  contents.Message = smithy_client_1.expectString(data.Message);
2740
1969
  }
2741
- return contents;
1970
+ const exception = new models_0_1.AccessDeniedException({
1971
+ $metadata: deserializeMetadata(parsedOutput),
1972
+ ...contents,
1973
+ });
1974
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
2742
1975
  };
2743
1976
  const deserializeAws_restJson1IllegalActionExceptionResponse = async (parsedOutput, context) => {
2744
- const contents = {
2745
- name: "IllegalActionException",
2746
- $fault: "client",
2747
- $metadata: deserializeMetadata(parsedOutput),
2748
- Message: undefined,
2749
- };
1977
+ const contents = {};
2750
1978
  const data = parsedOutput.body;
2751
1979
  if (data.Message !== undefined && data.Message !== null) {
2752
1980
  contents.Message = smithy_client_1.expectString(data.Message);
2753
1981
  }
2754
- return contents;
1982
+ const exception = new models_0_1.IllegalActionException({
1983
+ $metadata: deserializeMetadata(parsedOutput),
1984
+ ...contents,
1985
+ });
1986
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
2755
1987
  };
2756
1988
  const deserializeAws_restJson1InternalServiceErrorExceptionResponse = async (parsedOutput, context) => {
2757
- const contents = {
2758
- name: "InternalServiceErrorException",
2759
- $fault: "server",
2760
- $metadata: deserializeMetadata(parsedOutput),
2761
- };
1989
+ const contents = {};
2762
1990
  const data = parsedOutput.body;
2763
- return contents;
1991
+ const exception = new models_0_1.InternalServiceErrorException({
1992
+ $metadata: deserializeMetadata(parsedOutput),
1993
+ ...contents,
1994
+ });
1995
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
2764
1996
  };
2765
1997
  const deserializeAws_restJson1InvalidRequestExceptionResponse = async (parsedOutput, context) => {
2766
- const contents = {
2767
- name: "InvalidRequestException",
2768
- $fault: "client",
2769
- $metadata: deserializeMetadata(parsedOutput),
2770
- Message: undefined,
2771
- };
1998
+ const contents = {};
2772
1999
  const data = parsedOutput.body;
2773
2000
  if (data.Message !== undefined && data.Message !== null) {
2774
2001
  contents.Message = smithy_client_1.expectString(data.Message);
2775
2002
  }
2776
- return contents;
2003
+ const exception = new models_0_1.InvalidRequestException({
2004
+ $metadata: deserializeMetadata(parsedOutput),
2005
+ ...contents,
2006
+ });
2007
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
2777
2008
  };
2778
2009
  const deserializeAws_restJson1ResourceAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
2779
- const contents = {
2780
- name: "ResourceAlreadyExistsException",
2781
- $fault: "client",
2782
- $metadata: deserializeMetadata(parsedOutput),
2783
- Message: undefined,
2784
- };
2010
+ const contents = {};
2785
2011
  const data = parsedOutput.body;
2786
2012
  if (data.Message !== undefined && data.Message !== null) {
2787
2013
  contents.Message = smithy_client_1.expectString(data.Message);
2788
2014
  }
2789
- return contents;
2015
+ const exception = new models_0_1.ResourceAlreadyExistsException({
2016
+ $metadata: deserializeMetadata(parsedOutput),
2017
+ ...contents,
2018
+ });
2019
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
2790
2020
  };
2791
2021
  const deserializeAws_restJson1ResourceLimitExceededExceptionResponse = async (parsedOutput, context) => {
2792
- const contents = {
2793
- name: "ResourceLimitExceededException",
2794
- $fault: "client",
2795
- $metadata: deserializeMetadata(parsedOutput),
2796
- Message: undefined,
2797
- };
2022
+ const contents = {};
2798
2023
  const data = parsedOutput.body;
2799
2024
  if (data.Message !== undefined && data.Message !== null) {
2800
2025
  contents.Message = smithy_client_1.expectString(data.Message);
2801
2026
  }
2802
- return contents;
2027
+ const exception = new models_0_1.ResourceLimitExceededException({
2028
+ $metadata: deserializeMetadata(parsedOutput),
2029
+ ...contents,
2030
+ });
2031
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
2803
2032
  };
2804
2033
  const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
2805
- const contents = {
2806
- name: "ResourceNotFoundException",
2807
- $fault: "client",
2808
- $metadata: deserializeMetadata(parsedOutput),
2809
- Message: undefined,
2810
- ResourceName: undefined,
2811
- };
2034
+ const contents = {};
2812
2035
  const data = parsedOutput.body;
2813
2036
  if (data.Message !== undefined && data.Message !== null) {
2814
2037
  contents.Message = smithy_client_1.expectString(data.Message);
@@ -2816,38 +2039,35 @@ const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedO
2816
2039
  if (data.ResourceName !== undefined && data.ResourceName !== null) {
2817
2040
  contents.ResourceName = smithy_client_1.expectString(data.ResourceName);
2818
2041
  }
2819
- return contents;
2042
+ const exception = new models_0_1.ResourceNotFoundException({
2043
+ $metadata: deserializeMetadata(parsedOutput),
2044
+ ...contents,
2045
+ });
2046
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
2820
2047
  };
2821
2048
  const deserializeAws_restJson1ResourceNotReadyExceptionResponse = async (parsedOutput, context) => {
2822
- const contents = {
2823
- name: "ResourceNotReadyException",
2824
- $fault: "client",
2825
- $metadata: deserializeMetadata(parsedOutput),
2826
- Message: undefined,
2827
- };
2049
+ const contents = {};
2828
2050
  const data = parsedOutput.body;
2829
2051
  if (data.Message !== undefined && data.Message !== null) {
2830
2052
  contents.Message = smithy_client_1.expectString(data.Message);
2831
2053
  }
2832
- return contents;
2054
+ const exception = new models_0_1.ResourceNotReadyException({
2055
+ $metadata: deserializeMetadata(parsedOutput),
2056
+ ...contents,
2057
+ });
2058
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
2833
2059
  };
2834
2060
  const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput, context) => {
2835
- const contents = {
2836
- name: "ThrottlingException",
2837
- $fault: "client",
2838
- $metadata: deserializeMetadata(parsedOutput),
2839
- };
2061
+ const contents = {};
2840
2062
  const data = parsedOutput.body;
2841
- return contents;
2063
+ const exception = new models_0_1.ThrottlingException({
2064
+ $metadata: deserializeMetadata(parsedOutput),
2065
+ ...contents,
2066
+ });
2067
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
2842
2068
  };
2843
2069
  const deserializeAws_restJson1TooManyTagsExceptionResponse = async (parsedOutput, context) => {
2844
- const contents = {
2845
- name: "TooManyTagsException",
2846
- $fault: "client",
2847
- $metadata: deserializeMetadata(parsedOutput),
2848
- Message: undefined,
2849
- ResourceName: undefined,
2850
- };
2070
+ const contents = {};
2851
2071
  const data = parsedOutput.body;
2852
2072
  if (data.Message !== undefined && data.Message !== null) {
2853
2073
  contents.Message = smithy_client_1.expectString(data.Message);
@@ -2855,7 +2075,11 @@ const deserializeAws_restJson1TooManyTagsExceptionResponse = async (parsedOutput
2855
2075
  if (data.ResourceName !== undefined && data.ResourceName !== null) {
2856
2076
  contents.ResourceName = smithy_client_1.expectString(data.ResourceName);
2857
2077
  }
2858
- return contents;
2078
+ const exception = new models_0_1.TooManyTagsException({
2079
+ $metadata: deserializeMetadata(parsedOutput),
2080
+ ...contents,
2081
+ });
2082
+ return smithy_client_1.decorateServiceException(exception, parsedOutput.body);
2859
2083
  };
2860
2084
  const serializeAws_restJson1ApprovalThresholdPolicy = (input, context) => {
2861
2085
  return {
@@ -3045,7 +2269,7 @@ const deserializeAws_restJson1Invitation = (output, context) => {
3045
2269
  };
3046
2270
  };
3047
2271
  const deserializeAws_restJson1InvitationList = (output, context) => {
3048
- return (output || [])
2272
+ const retVal = (output || [])
3049
2273
  .filter((e) => e != null)
3050
2274
  .map((entry) => {
3051
2275
  if (entry === null) {
@@ -3053,6 +2277,7 @@ const deserializeAws_restJson1InvitationList = (output, context) => {
3053
2277
  }
3054
2278
  return deserializeAws_restJson1Invitation(entry, context);
3055
2279
  });
2280
+ return retVal;
3056
2281
  };
3057
2282
  const deserializeAws_restJson1InviteAction = (output, context) => {
3058
2283
  return {
@@ -3060,7 +2285,7 @@ const deserializeAws_restJson1InviteAction = (output, context) => {
3060
2285
  };
3061
2286
  };
3062
2287
  const deserializeAws_restJson1InviteActionList = (output, context) => {
3063
- return (output || [])
2288
+ const retVal = (output || [])
3064
2289
  .filter((e) => e != null)
3065
2290
  .map((entry) => {
3066
2291
  if (entry === null) {
@@ -3068,6 +2293,7 @@ const deserializeAws_restJson1InviteActionList = (output, context) => {
3068
2293
  }
3069
2294
  return deserializeAws_restJson1InviteAction(entry, context);
3070
2295
  });
2296
+ return retVal;
3071
2297
  };
3072
2298
  const deserializeAws_restJson1LogConfiguration = (output, context) => {
3073
2299
  return {
@@ -3145,7 +2371,7 @@ const deserializeAws_restJson1MemberSummary = (output, context) => {
3145
2371
  };
3146
2372
  };
3147
2373
  const deserializeAws_restJson1MemberSummaryList = (output, context) => {
3148
- return (output || [])
2374
+ const retVal = (output || [])
3149
2375
  .filter((e) => e != null)
3150
2376
  .map((entry) => {
3151
2377
  if (entry === null) {
@@ -3153,6 +2379,7 @@ const deserializeAws_restJson1MemberSummaryList = (output, context) => {
3153
2379
  }
3154
2380
  return deserializeAws_restJson1MemberSummary(entry, context);
3155
2381
  });
2382
+ return retVal;
3156
2383
  };
3157
2384
  const deserializeAws_restJson1Network = (output, context) => {
3158
2385
  return {
@@ -3214,7 +2441,7 @@ const deserializeAws_restJson1NetworkSummary = (output, context) => {
3214
2441
  };
3215
2442
  };
3216
2443
  const deserializeAws_restJson1NetworkSummaryList = (output, context) => {
3217
- return (output || [])
2444
+ const retVal = (output || [])
3218
2445
  .filter((e) => e != null)
3219
2446
  .map((entry) => {
3220
2447
  if (entry === null) {
@@ -3222,6 +2449,7 @@ const deserializeAws_restJson1NetworkSummaryList = (output, context) => {
3222
2449
  }
3223
2450
  return deserializeAws_restJson1NetworkSummary(entry, context);
3224
2451
  });
2452
+ return retVal;
3225
2453
  };
3226
2454
  const deserializeAws_restJson1Node = (output, context) => {
3227
2455
  return {
@@ -3300,7 +2528,7 @@ const deserializeAws_restJson1NodeSummary = (output, context) => {
3300
2528
  };
3301
2529
  };
3302
2530
  const deserializeAws_restJson1NodeSummaryList = (output, context) => {
3303
- return (output || [])
2531
+ const retVal = (output || [])
3304
2532
  .filter((e) => e != null)
3305
2533
  .map((entry) => {
3306
2534
  if (entry === null) {
@@ -3308,6 +2536,7 @@ const deserializeAws_restJson1NodeSummaryList = (output, context) => {
3308
2536
  }
3309
2537
  return deserializeAws_restJson1NodeSummary(entry, context);
3310
2538
  });
2539
+ return retVal;
3311
2540
  };
3312
2541
  const deserializeAws_restJson1OutputTagMap = (output, context) => {
3313
2542
  return Object.entries(output).reduce((acc, [key, value]) => {
@@ -3373,7 +2602,7 @@ const deserializeAws_restJson1ProposalSummary = (output, context) => {
3373
2602
  };
3374
2603
  };
3375
2604
  const deserializeAws_restJson1ProposalSummaryList = (output, context) => {
3376
- return (output || [])
2605
+ const retVal = (output || [])
3377
2606
  .filter((e) => e != null)
3378
2607
  .map((entry) => {
3379
2608
  if (entry === null) {
@@ -3381,9 +2610,10 @@ const deserializeAws_restJson1ProposalSummaryList = (output, context) => {
3381
2610
  }
3382
2611
  return deserializeAws_restJson1ProposalSummary(entry, context);
3383
2612
  });
2613
+ return retVal;
3384
2614
  };
3385
2615
  const deserializeAws_restJson1ProposalVoteList = (output, context) => {
3386
- return (output || [])
2616
+ const retVal = (output || [])
3387
2617
  .filter((e) => e != null)
3388
2618
  .map((entry) => {
3389
2619
  if (entry === null) {
@@ -3391,6 +2621,7 @@ const deserializeAws_restJson1ProposalVoteList = (output, context) => {
3391
2621
  }
3392
2622
  return deserializeAws_restJson1VoteSummary(entry, context);
3393
2623
  });
2624
+ return retVal;
3394
2625
  };
3395
2626
  const deserializeAws_restJson1RemoveAction = (output, context) => {
3396
2627
  return {
@@ -3398,7 +2629,7 @@ const deserializeAws_restJson1RemoveAction = (output, context) => {
3398
2629
  };
3399
2630
  };
3400
2631
  const deserializeAws_restJson1RemoveActionList = (output, context) => {
3401
- return (output || [])
2632
+ const retVal = (output || [])
3402
2633
  .filter((e) => e != null)
3403
2634
  .map((entry) => {
3404
2635
  if (entry === null) {
@@ -3406,6 +2637,7 @@ const deserializeAws_restJson1RemoveActionList = (output, context) => {
3406
2637
  }
3407
2638
  return deserializeAws_restJson1RemoveAction(entry, context);
3408
2639
  });
2640
+ return retVal;
3409
2641
  };
3410
2642
  const deserializeAws_restJson1VoteSummary = (output, context) => {
3411
2643
  return {