@aws-sdk/client-opensearch 3.504.0 → 3.507.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist-cjs/index.js +122 -1929
  2. package/dist-es/protocols/Aws_restJson1.js +115 -1922
  3. package/package.json +3 -3
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -819,7 +819,7 @@ export const se_UpgradeDomainCommand = async (input, context) => {
819
819
  };
820
820
  export const de_AcceptInboundConnectionCommand = async (output, context) => {
821
821
  if (output.statusCode !== 200 && output.statusCode >= 300) {
822
- return de_AcceptInboundConnectionCommandError(output, context);
822
+ return de_CommandError(output, context);
823
823
  }
824
824
  const contents = map({
825
825
  $metadata: deserializeMetadata(output),
@@ -831,34 +831,9 @@ export const de_AcceptInboundConnectionCommand = async (output, context) => {
831
831
  Object.assign(contents, doc);
832
832
  return contents;
833
833
  };
834
- const de_AcceptInboundConnectionCommandError = async (output, context) => {
835
- const parsedOutput = {
836
- ...output,
837
- body: await parseErrorBody(output.body, context),
838
- };
839
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
840
- switch (errorCode) {
841
- case "DisabledOperationException":
842
- case "com.amazonaws.opensearch#DisabledOperationException":
843
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
844
- case "LimitExceededException":
845
- case "com.amazonaws.opensearch#LimitExceededException":
846
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
847
- case "ResourceNotFoundException":
848
- case "com.amazonaws.opensearch#ResourceNotFoundException":
849
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
850
- default:
851
- const parsedBody = parsedOutput.body;
852
- return throwDefaultError({
853
- output,
854
- parsedBody,
855
- errorCode,
856
- });
857
- }
858
- };
859
834
  export const de_AddDataSourceCommand = async (output, context) => {
860
835
  if (output.statusCode !== 200 && output.statusCode >= 300) {
861
- return de_AddDataSourceCommandError(output, context);
836
+ return de_CommandError(output, context);
862
837
  }
863
838
  const contents = map({
864
839
  $metadata: deserializeMetadata(output),
@@ -870,46 +845,9 @@ export const de_AddDataSourceCommand = async (output, context) => {
870
845
  Object.assign(contents, doc);
871
846
  return contents;
872
847
  };
873
- const de_AddDataSourceCommandError = async (output, context) => {
874
- const parsedOutput = {
875
- ...output,
876
- body: await parseErrorBody(output.body, context),
877
- };
878
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
879
- switch (errorCode) {
880
- case "BaseException":
881
- case "com.amazonaws.opensearch#BaseException":
882
- throw await de_BaseExceptionRes(parsedOutput, context);
883
- case "DependencyFailureException":
884
- case "com.amazonaws.opensearch#DependencyFailureException":
885
- throw await de_DependencyFailureExceptionRes(parsedOutput, context);
886
- case "DisabledOperationException":
887
- case "com.amazonaws.opensearch#DisabledOperationException":
888
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
889
- case "InternalException":
890
- case "com.amazonaws.opensearch#InternalException":
891
- throw await de_InternalExceptionRes(parsedOutput, context);
892
- case "LimitExceededException":
893
- case "com.amazonaws.opensearch#LimitExceededException":
894
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
895
- case "ResourceNotFoundException":
896
- case "com.amazonaws.opensearch#ResourceNotFoundException":
897
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
898
- case "ValidationException":
899
- case "com.amazonaws.opensearch#ValidationException":
900
- throw await de_ValidationExceptionRes(parsedOutput, context);
901
- default:
902
- const parsedBody = parsedOutput.body;
903
- return throwDefaultError({
904
- output,
905
- parsedBody,
906
- errorCode,
907
- });
908
- }
909
- };
910
848
  export const de_AddTagsCommand = async (output, context) => {
911
849
  if (output.statusCode !== 200 && output.statusCode >= 300) {
912
- return de_AddTagsCommandError(output, context);
850
+ return de_CommandError(output, context);
913
851
  }
914
852
  const contents = map({
915
853
  $metadata: deserializeMetadata(output),
@@ -917,37 +855,9 @@ export const de_AddTagsCommand = async (output, context) => {
917
855
  await collectBody(output.body, context);
918
856
  return contents;
919
857
  };
920
- const de_AddTagsCommandError = async (output, context) => {
921
- const parsedOutput = {
922
- ...output,
923
- body: await parseErrorBody(output.body, context),
924
- };
925
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
926
- switch (errorCode) {
927
- case "BaseException":
928
- case "com.amazonaws.opensearch#BaseException":
929
- throw await de_BaseExceptionRes(parsedOutput, context);
930
- case "InternalException":
931
- case "com.amazonaws.opensearch#InternalException":
932
- throw await de_InternalExceptionRes(parsedOutput, context);
933
- case "LimitExceededException":
934
- case "com.amazonaws.opensearch#LimitExceededException":
935
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
936
- case "ValidationException":
937
- case "com.amazonaws.opensearch#ValidationException":
938
- throw await de_ValidationExceptionRes(parsedOutput, context);
939
- default:
940
- const parsedBody = parsedOutput.body;
941
- return throwDefaultError({
942
- output,
943
- parsedBody,
944
- errorCode,
945
- });
946
- }
947
- };
948
858
  export const de_AssociatePackageCommand = async (output, context) => {
949
859
  if (output.statusCode !== 200 && output.statusCode >= 300) {
950
- return de_AssociatePackageCommandError(output, context);
860
+ return de_CommandError(output, context);
951
861
  }
952
862
  const contents = map({
953
863
  $metadata: deserializeMetadata(output),
@@ -959,43 +869,9 @@ export const de_AssociatePackageCommand = async (output, context) => {
959
869
  Object.assign(contents, doc);
960
870
  return contents;
961
871
  };
962
- const de_AssociatePackageCommandError = async (output, context) => {
963
- const parsedOutput = {
964
- ...output,
965
- body: await parseErrorBody(output.body, context),
966
- };
967
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
968
- switch (errorCode) {
969
- case "AccessDeniedException":
970
- case "com.amazonaws.opensearch#AccessDeniedException":
971
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
972
- case "BaseException":
973
- case "com.amazonaws.opensearch#BaseException":
974
- throw await de_BaseExceptionRes(parsedOutput, context);
975
- case "ConflictException":
976
- case "com.amazonaws.opensearch#ConflictException":
977
- throw await de_ConflictExceptionRes(parsedOutput, context);
978
- case "InternalException":
979
- case "com.amazonaws.opensearch#InternalException":
980
- throw await de_InternalExceptionRes(parsedOutput, context);
981
- case "ResourceNotFoundException":
982
- case "com.amazonaws.opensearch#ResourceNotFoundException":
983
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
984
- case "ValidationException":
985
- case "com.amazonaws.opensearch#ValidationException":
986
- throw await de_ValidationExceptionRes(parsedOutput, context);
987
- default:
988
- const parsedBody = parsedOutput.body;
989
- return throwDefaultError({
990
- output,
991
- parsedBody,
992
- errorCode,
993
- });
994
- }
995
- };
996
872
  export const de_AuthorizeVpcEndpointAccessCommand = async (output, context) => {
997
873
  if (output.statusCode !== 200 && output.statusCode >= 300) {
998
- return de_AuthorizeVpcEndpointAccessCommandError(output, context);
874
+ return de_CommandError(output, context);
999
875
  }
1000
876
  const contents = map({
1001
877
  $metadata: deserializeMetadata(output),
@@ -1007,43 +883,9 @@ export const de_AuthorizeVpcEndpointAccessCommand = async (output, context) => {
1007
883
  Object.assign(contents, doc);
1008
884
  return contents;
1009
885
  };
1010
- const de_AuthorizeVpcEndpointAccessCommandError = async (output, context) => {
1011
- const parsedOutput = {
1012
- ...output,
1013
- body: await parseErrorBody(output.body, context),
1014
- };
1015
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1016
- switch (errorCode) {
1017
- case "BaseException":
1018
- case "com.amazonaws.opensearch#BaseException":
1019
- throw await de_BaseExceptionRes(parsedOutput, context);
1020
- case "DisabledOperationException":
1021
- case "com.amazonaws.opensearch#DisabledOperationException":
1022
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1023
- case "InternalException":
1024
- case "com.amazonaws.opensearch#InternalException":
1025
- throw await de_InternalExceptionRes(parsedOutput, context);
1026
- case "LimitExceededException":
1027
- case "com.amazonaws.opensearch#LimitExceededException":
1028
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1029
- case "ResourceNotFoundException":
1030
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1031
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1032
- case "ValidationException":
1033
- case "com.amazonaws.opensearch#ValidationException":
1034
- throw await de_ValidationExceptionRes(parsedOutput, context);
1035
- default:
1036
- const parsedBody = parsedOutput.body;
1037
- return throwDefaultError({
1038
- output,
1039
- parsedBody,
1040
- errorCode,
1041
- });
1042
- }
1043
- };
1044
886
  export const de_CancelServiceSoftwareUpdateCommand = async (output, context) => {
1045
887
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1046
- return de_CancelServiceSoftwareUpdateCommandError(output, context);
888
+ return de_CommandError(output, context);
1047
889
  }
1048
890
  const contents = map({
1049
891
  $metadata: deserializeMetadata(output),
@@ -1055,37 +897,9 @@ export const de_CancelServiceSoftwareUpdateCommand = async (output, context) =>
1055
897
  Object.assign(contents, doc);
1056
898
  return contents;
1057
899
  };
1058
- const de_CancelServiceSoftwareUpdateCommandError = async (output, context) => {
1059
- const parsedOutput = {
1060
- ...output,
1061
- body: await parseErrorBody(output.body, context),
1062
- };
1063
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1064
- switch (errorCode) {
1065
- case "BaseException":
1066
- case "com.amazonaws.opensearch#BaseException":
1067
- throw await de_BaseExceptionRes(parsedOutput, context);
1068
- case "InternalException":
1069
- case "com.amazonaws.opensearch#InternalException":
1070
- throw await de_InternalExceptionRes(parsedOutput, context);
1071
- case "ResourceNotFoundException":
1072
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1073
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1074
- case "ValidationException":
1075
- case "com.amazonaws.opensearch#ValidationException":
1076
- throw await de_ValidationExceptionRes(parsedOutput, context);
1077
- default:
1078
- const parsedBody = parsedOutput.body;
1079
- return throwDefaultError({
1080
- output,
1081
- parsedBody,
1082
- errorCode,
1083
- });
1084
- }
1085
- };
1086
900
  export const de_CreateDomainCommand = async (output, context) => {
1087
901
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1088
- return de_CreateDomainCommandError(output, context);
902
+ return de_CommandError(output, context);
1089
903
  }
1090
904
  const contents = map({
1091
905
  $metadata: deserializeMetadata(output),
@@ -1097,46 +911,9 @@ export const de_CreateDomainCommand = async (output, context) => {
1097
911
  Object.assign(contents, doc);
1098
912
  return contents;
1099
913
  };
1100
- const de_CreateDomainCommandError = async (output, context) => {
1101
- const parsedOutput = {
1102
- ...output,
1103
- body: await parseErrorBody(output.body, context),
1104
- };
1105
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1106
- switch (errorCode) {
1107
- case "BaseException":
1108
- case "com.amazonaws.opensearch#BaseException":
1109
- throw await de_BaseExceptionRes(parsedOutput, context);
1110
- case "DisabledOperationException":
1111
- case "com.amazonaws.opensearch#DisabledOperationException":
1112
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1113
- case "InternalException":
1114
- case "com.amazonaws.opensearch#InternalException":
1115
- throw await de_InternalExceptionRes(parsedOutput, context);
1116
- case "InvalidTypeException":
1117
- case "com.amazonaws.opensearch#InvalidTypeException":
1118
- throw await de_InvalidTypeExceptionRes(parsedOutput, context);
1119
- case "LimitExceededException":
1120
- case "com.amazonaws.opensearch#LimitExceededException":
1121
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1122
- case "ResourceAlreadyExistsException":
1123
- case "com.amazonaws.opensearch#ResourceAlreadyExistsException":
1124
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
1125
- case "ValidationException":
1126
- case "com.amazonaws.opensearch#ValidationException":
1127
- throw await de_ValidationExceptionRes(parsedOutput, context);
1128
- default:
1129
- const parsedBody = parsedOutput.body;
1130
- return throwDefaultError({
1131
- output,
1132
- parsedBody,
1133
- errorCode,
1134
- });
1135
- }
1136
- };
1137
914
  export const de_CreateOutboundConnectionCommand = async (output, context) => {
1138
915
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1139
- return de_CreateOutboundConnectionCommandError(output, context);
916
+ return de_CommandError(output, context);
1140
917
  }
1141
918
  const contents = map({
1142
919
  $metadata: deserializeMetadata(output),
@@ -1154,37 +931,9 @@ export const de_CreateOutboundConnectionCommand = async (output, context) => {
1154
931
  Object.assign(contents, doc);
1155
932
  return contents;
1156
933
  };
1157
- const de_CreateOutboundConnectionCommandError = async (output, context) => {
1158
- const parsedOutput = {
1159
- ...output,
1160
- body: await parseErrorBody(output.body, context),
1161
- };
1162
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1163
- switch (errorCode) {
1164
- case "DisabledOperationException":
1165
- case "com.amazonaws.opensearch#DisabledOperationException":
1166
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1167
- case "InternalException":
1168
- case "com.amazonaws.opensearch#InternalException":
1169
- throw await de_InternalExceptionRes(parsedOutput, context);
1170
- case "LimitExceededException":
1171
- case "com.amazonaws.opensearch#LimitExceededException":
1172
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1173
- case "ResourceAlreadyExistsException":
1174
- case "com.amazonaws.opensearch#ResourceAlreadyExistsException":
1175
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
1176
- default:
1177
- const parsedBody = parsedOutput.body;
1178
- return throwDefaultError({
1179
- output,
1180
- parsedBody,
1181
- errorCode,
1182
- });
1183
- }
1184
- };
1185
934
  export const de_CreatePackageCommand = async (output, context) => {
1186
935
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1187
- return de_CreatePackageCommandError(output, context);
936
+ return de_CommandError(output, context);
1188
937
  }
1189
938
  const contents = map({
1190
939
  $metadata: deserializeMetadata(output),
@@ -1196,46 +945,9 @@ export const de_CreatePackageCommand = async (output, context) => {
1196
945
  Object.assign(contents, doc);
1197
946
  return contents;
1198
947
  };
1199
- const de_CreatePackageCommandError = async (output, context) => {
1200
- const parsedOutput = {
1201
- ...output,
1202
- body: await parseErrorBody(output.body, context),
1203
- };
1204
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1205
- switch (errorCode) {
1206
- case "AccessDeniedException":
1207
- case "com.amazonaws.opensearch#AccessDeniedException":
1208
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1209
- case "BaseException":
1210
- case "com.amazonaws.opensearch#BaseException":
1211
- throw await de_BaseExceptionRes(parsedOutput, context);
1212
- case "InternalException":
1213
- case "com.amazonaws.opensearch#InternalException":
1214
- throw await de_InternalExceptionRes(parsedOutput, context);
1215
- case "InvalidTypeException":
1216
- case "com.amazonaws.opensearch#InvalidTypeException":
1217
- throw await de_InvalidTypeExceptionRes(parsedOutput, context);
1218
- case "LimitExceededException":
1219
- case "com.amazonaws.opensearch#LimitExceededException":
1220
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1221
- case "ResourceAlreadyExistsException":
1222
- case "com.amazonaws.opensearch#ResourceAlreadyExistsException":
1223
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
1224
- case "ValidationException":
1225
- case "com.amazonaws.opensearch#ValidationException":
1226
- throw await de_ValidationExceptionRes(parsedOutput, context);
1227
- default:
1228
- const parsedBody = parsedOutput.body;
1229
- return throwDefaultError({
1230
- output,
1231
- parsedBody,
1232
- errorCode,
1233
- });
1234
- }
1235
- };
1236
948
  export const de_CreateVpcEndpointCommand = async (output, context) => {
1237
949
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1238
- return de_CreateVpcEndpointCommandError(output, context);
950
+ return de_CommandError(output, context);
1239
951
  }
1240
952
  const contents = map({
1241
953
  $metadata: deserializeMetadata(output),
@@ -1247,43 +959,9 @@ export const de_CreateVpcEndpointCommand = async (output, context) => {
1247
959
  Object.assign(contents, doc);
1248
960
  return contents;
1249
961
  };
1250
- const de_CreateVpcEndpointCommandError = async (output, context) => {
1251
- const parsedOutput = {
1252
- ...output,
1253
- body: await parseErrorBody(output.body, context),
1254
- };
1255
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1256
- switch (errorCode) {
1257
- case "BaseException":
1258
- case "com.amazonaws.opensearch#BaseException":
1259
- throw await de_BaseExceptionRes(parsedOutput, context);
1260
- case "ConflictException":
1261
- case "com.amazonaws.opensearch#ConflictException":
1262
- throw await de_ConflictExceptionRes(parsedOutput, context);
1263
- case "DisabledOperationException":
1264
- case "com.amazonaws.opensearch#DisabledOperationException":
1265
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1266
- case "InternalException":
1267
- case "com.amazonaws.opensearch#InternalException":
1268
- throw await de_InternalExceptionRes(parsedOutput, context);
1269
- case "LimitExceededException":
1270
- case "com.amazonaws.opensearch#LimitExceededException":
1271
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1272
- case "ValidationException":
1273
- case "com.amazonaws.opensearch#ValidationException":
1274
- throw await de_ValidationExceptionRes(parsedOutput, context);
1275
- default:
1276
- const parsedBody = parsedOutput.body;
1277
- return throwDefaultError({
1278
- output,
1279
- parsedBody,
1280
- errorCode,
1281
- });
1282
- }
1283
- };
1284
962
  export const de_DeleteDataSourceCommand = async (output, context) => {
1285
963
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1286
- return de_DeleteDataSourceCommandError(output, context);
964
+ return de_CommandError(output, context);
1287
965
  }
1288
966
  const contents = map({
1289
967
  $metadata: deserializeMetadata(output),
@@ -1295,43 +973,9 @@ export const de_DeleteDataSourceCommand = async (output, context) => {
1295
973
  Object.assign(contents, doc);
1296
974
  return contents;
1297
975
  };
1298
- const de_DeleteDataSourceCommandError = async (output, context) => {
1299
- const parsedOutput = {
1300
- ...output,
1301
- body: await parseErrorBody(output.body, context),
1302
- };
1303
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1304
- switch (errorCode) {
1305
- case "BaseException":
1306
- case "com.amazonaws.opensearch#BaseException":
1307
- throw await de_BaseExceptionRes(parsedOutput, context);
1308
- case "DependencyFailureException":
1309
- case "com.amazonaws.opensearch#DependencyFailureException":
1310
- throw await de_DependencyFailureExceptionRes(parsedOutput, context);
1311
- case "DisabledOperationException":
1312
- case "com.amazonaws.opensearch#DisabledOperationException":
1313
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1314
- case "InternalException":
1315
- case "com.amazonaws.opensearch#InternalException":
1316
- throw await de_InternalExceptionRes(parsedOutput, context);
1317
- case "ResourceNotFoundException":
1318
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1319
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1320
- case "ValidationException":
1321
- case "com.amazonaws.opensearch#ValidationException":
1322
- throw await de_ValidationExceptionRes(parsedOutput, context);
1323
- default:
1324
- const parsedBody = parsedOutput.body;
1325
- return throwDefaultError({
1326
- output,
1327
- parsedBody,
1328
- errorCode,
1329
- });
1330
- }
1331
- };
1332
976
  export const de_DeleteDomainCommand = async (output, context) => {
1333
977
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1334
- return de_DeleteDomainCommandError(output, context);
978
+ return de_CommandError(output, context);
1335
979
  }
1336
980
  const contents = map({
1337
981
  $metadata: deserializeMetadata(output),
@@ -1343,37 +987,9 @@ export const de_DeleteDomainCommand = async (output, context) => {
1343
987
  Object.assign(contents, doc);
1344
988
  return contents;
1345
989
  };
1346
- const de_DeleteDomainCommandError = async (output, context) => {
1347
- const parsedOutput = {
1348
- ...output,
1349
- body: await parseErrorBody(output.body, context),
1350
- };
1351
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1352
- switch (errorCode) {
1353
- case "BaseException":
1354
- case "com.amazonaws.opensearch#BaseException":
1355
- throw await de_BaseExceptionRes(parsedOutput, context);
1356
- case "InternalException":
1357
- case "com.amazonaws.opensearch#InternalException":
1358
- throw await de_InternalExceptionRes(parsedOutput, context);
1359
- case "ResourceNotFoundException":
1360
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1361
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1362
- case "ValidationException":
1363
- case "com.amazonaws.opensearch#ValidationException":
1364
- throw await de_ValidationExceptionRes(parsedOutput, context);
1365
- default:
1366
- const parsedBody = parsedOutput.body;
1367
- return throwDefaultError({
1368
- output,
1369
- parsedBody,
1370
- errorCode,
1371
- });
1372
- }
1373
- };
1374
990
  export const de_DeleteInboundConnectionCommand = async (output, context) => {
1375
991
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1376
- return de_DeleteInboundConnectionCommandError(output, context);
992
+ return de_CommandError(output, context);
1377
993
  }
1378
994
  const contents = map({
1379
995
  $metadata: deserializeMetadata(output),
@@ -1385,31 +1001,9 @@ export const de_DeleteInboundConnectionCommand = async (output, context) => {
1385
1001
  Object.assign(contents, doc);
1386
1002
  return contents;
1387
1003
  };
1388
- const de_DeleteInboundConnectionCommandError = async (output, context) => {
1389
- const parsedOutput = {
1390
- ...output,
1391
- body: await parseErrorBody(output.body, context),
1392
- };
1393
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1394
- switch (errorCode) {
1395
- case "DisabledOperationException":
1396
- case "com.amazonaws.opensearch#DisabledOperationException":
1397
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1398
- case "ResourceNotFoundException":
1399
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1400
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1401
- default:
1402
- const parsedBody = parsedOutput.body;
1403
- return throwDefaultError({
1404
- output,
1405
- parsedBody,
1406
- errorCode,
1407
- });
1408
- }
1409
- };
1410
1004
  export const de_DeleteOutboundConnectionCommand = async (output, context) => {
1411
1005
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1412
- return de_DeleteOutboundConnectionCommandError(output, context);
1006
+ return de_CommandError(output, context);
1413
1007
  }
1414
1008
  const contents = map({
1415
1009
  $metadata: deserializeMetadata(output),
@@ -1421,31 +1015,9 @@ export const de_DeleteOutboundConnectionCommand = async (output, context) => {
1421
1015
  Object.assign(contents, doc);
1422
1016
  return contents;
1423
1017
  };
1424
- const de_DeleteOutboundConnectionCommandError = async (output, context) => {
1425
- const parsedOutput = {
1426
- ...output,
1427
- body: await parseErrorBody(output.body, context),
1428
- };
1429
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1430
- switch (errorCode) {
1431
- case "DisabledOperationException":
1432
- case "com.amazonaws.opensearch#DisabledOperationException":
1433
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1434
- case "ResourceNotFoundException":
1435
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1436
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1437
- default:
1438
- const parsedBody = parsedOutput.body;
1439
- return throwDefaultError({
1440
- output,
1441
- parsedBody,
1442
- errorCode,
1443
- });
1444
- }
1445
- };
1446
1018
  export const de_DeletePackageCommand = async (output, context) => {
1447
1019
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1448
- return de_DeletePackageCommandError(output, context);
1020
+ return de_CommandError(output, context);
1449
1021
  }
1450
1022
  const contents = map({
1451
1023
  $metadata: deserializeMetadata(output),
@@ -1457,43 +1029,9 @@ export const de_DeletePackageCommand = async (output, context) => {
1457
1029
  Object.assign(contents, doc);
1458
1030
  return contents;
1459
1031
  };
1460
- const de_DeletePackageCommandError = async (output, context) => {
1461
- const parsedOutput = {
1462
- ...output,
1463
- body: await parseErrorBody(output.body, context),
1464
- };
1465
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1466
- switch (errorCode) {
1467
- case "AccessDeniedException":
1468
- case "com.amazonaws.opensearch#AccessDeniedException":
1469
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1470
- case "BaseException":
1471
- case "com.amazonaws.opensearch#BaseException":
1472
- throw await de_BaseExceptionRes(parsedOutput, context);
1473
- case "ConflictException":
1474
- case "com.amazonaws.opensearch#ConflictException":
1475
- throw await de_ConflictExceptionRes(parsedOutput, context);
1476
- case "InternalException":
1477
- case "com.amazonaws.opensearch#InternalException":
1478
- throw await de_InternalExceptionRes(parsedOutput, context);
1479
- case "ResourceNotFoundException":
1480
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1481
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1482
- case "ValidationException":
1483
- case "com.amazonaws.opensearch#ValidationException":
1484
- throw await de_ValidationExceptionRes(parsedOutput, context);
1485
- default:
1486
- const parsedBody = parsedOutput.body;
1487
- return throwDefaultError({
1488
- output,
1489
- parsedBody,
1490
- errorCode,
1491
- });
1492
- }
1493
- };
1494
1032
  export const de_DeleteVpcEndpointCommand = async (output, context) => {
1495
1033
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1496
- return de_DeleteVpcEndpointCommandError(output, context);
1034
+ return de_CommandError(output, context);
1497
1035
  }
1498
1036
  const contents = map({
1499
1037
  $metadata: deserializeMetadata(output),
@@ -1505,37 +1043,9 @@ export const de_DeleteVpcEndpointCommand = async (output, context) => {
1505
1043
  Object.assign(contents, doc);
1506
1044
  return contents;
1507
1045
  };
1508
- const de_DeleteVpcEndpointCommandError = async (output, context) => {
1509
- const parsedOutput = {
1510
- ...output,
1511
- body: await parseErrorBody(output.body, context),
1512
- };
1513
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1514
- switch (errorCode) {
1515
- case "BaseException":
1516
- case "com.amazonaws.opensearch#BaseException":
1517
- throw await de_BaseExceptionRes(parsedOutput, context);
1518
- case "DisabledOperationException":
1519
- case "com.amazonaws.opensearch#DisabledOperationException":
1520
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1521
- case "InternalException":
1522
- case "com.amazonaws.opensearch#InternalException":
1523
- throw await de_InternalExceptionRes(parsedOutput, context);
1524
- case "ResourceNotFoundException":
1525
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1526
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1527
- default:
1528
- const parsedBody = parsedOutput.body;
1529
- return throwDefaultError({
1530
- output,
1531
- parsedBody,
1532
- errorCode,
1533
- });
1534
- }
1535
- };
1536
1046
  export const de_DescribeDomainCommand = async (output, context) => {
1537
1047
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1538
- return de_DescribeDomainCommandError(output, context);
1048
+ return de_CommandError(output, context);
1539
1049
  }
1540
1050
  const contents = map({
1541
1051
  $metadata: deserializeMetadata(output),
@@ -1547,37 +1057,9 @@ export const de_DescribeDomainCommand = async (output, context) => {
1547
1057
  Object.assign(contents, doc);
1548
1058
  return contents;
1549
1059
  };
1550
- const de_DescribeDomainCommandError = async (output, context) => {
1551
- const parsedOutput = {
1552
- ...output,
1553
- body: await parseErrorBody(output.body, context),
1554
- };
1555
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1556
- switch (errorCode) {
1557
- case "BaseException":
1558
- case "com.amazonaws.opensearch#BaseException":
1559
- throw await de_BaseExceptionRes(parsedOutput, context);
1560
- case "InternalException":
1561
- case "com.amazonaws.opensearch#InternalException":
1562
- throw await de_InternalExceptionRes(parsedOutput, context);
1563
- case "ResourceNotFoundException":
1564
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1565
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1566
- case "ValidationException":
1567
- case "com.amazonaws.opensearch#ValidationException":
1568
- throw await de_ValidationExceptionRes(parsedOutput, context);
1569
- default:
1570
- const parsedBody = parsedOutput.body;
1571
- return throwDefaultError({
1572
- output,
1573
- parsedBody,
1574
- errorCode,
1575
- });
1576
- }
1577
- };
1578
1060
  export const de_DescribeDomainAutoTunesCommand = async (output, context) => {
1579
1061
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1580
- return de_DescribeDomainAutoTunesCommandError(output, context);
1062
+ return de_CommandError(output, context);
1581
1063
  }
1582
1064
  const contents = map({
1583
1065
  $metadata: deserializeMetadata(output),
@@ -1590,37 +1072,9 @@ export const de_DescribeDomainAutoTunesCommand = async (output, context) => {
1590
1072
  Object.assign(contents, doc);
1591
1073
  return contents;
1592
1074
  };
1593
- const de_DescribeDomainAutoTunesCommandError = async (output, context) => {
1594
- const parsedOutput = {
1595
- ...output,
1596
- body: await parseErrorBody(output.body, context),
1597
- };
1598
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1599
- switch (errorCode) {
1600
- case "BaseException":
1601
- case "com.amazonaws.opensearch#BaseException":
1602
- throw await de_BaseExceptionRes(parsedOutput, context);
1603
- case "InternalException":
1604
- case "com.amazonaws.opensearch#InternalException":
1605
- throw await de_InternalExceptionRes(parsedOutput, context);
1606
- case "ResourceNotFoundException":
1607
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1608
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1609
- case "ValidationException":
1610
- case "com.amazonaws.opensearch#ValidationException":
1611
- throw await de_ValidationExceptionRes(parsedOutput, context);
1612
- default:
1613
- const parsedBody = parsedOutput.body;
1614
- return throwDefaultError({
1615
- output,
1616
- parsedBody,
1617
- errorCode,
1618
- });
1619
- }
1620
- };
1621
1075
  export const de_DescribeDomainChangeProgressCommand = async (output, context) => {
1622
1076
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1623
- return de_DescribeDomainChangeProgressCommandError(output, context);
1077
+ return de_CommandError(output, context);
1624
1078
  }
1625
1079
  const contents = map({
1626
1080
  $metadata: deserializeMetadata(output),
@@ -1632,37 +1086,9 @@ export const de_DescribeDomainChangeProgressCommand = async (output, context) =>
1632
1086
  Object.assign(contents, doc);
1633
1087
  return contents;
1634
1088
  };
1635
- const de_DescribeDomainChangeProgressCommandError = async (output, context) => {
1636
- const parsedOutput = {
1637
- ...output,
1638
- body: await parseErrorBody(output.body, context),
1639
- };
1640
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1641
- switch (errorCode) {
1642
- case "BaseException":
1643
- case "com.amazonaws.opensearch#BaseException":
1644
- throw await de_BaseExceptionRes(parsedOutput, context);
1645
- case "InternalException":
1646
- case "com.amazonaws.opensearch#InternalException":
1647
- throw await de_InternalExceptionRes(parsedOutput, context);
1648
- case "ResourceNotFoundException":
1649
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1650
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1651
- case "ValidationException":
1652
- case "com.amazonaws.opensearch#ValidationException":
1653
- throw await de_ValidationExceptionRes(parsedOutput, context);
1654
- default:
1655
- const parsedBody = parsedOutput.body;
1656
- return throwDefaultError({
1657
- output,
1658
- parsedBody,
1659
- errorCode,
1660
- });
1661
- }
1662
- };
1663
1089
  export const de_DescribeDomainConfigCommand = async (output, context) => {
1664
1090
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1665
- return de_DescribeDomainConfigCommandError(output, context);
1091
+ return de_CommandError(output, context);
1666
1092
  }
1667
1093
  const contents = map({
1668
1094
  $metadata: deserializeMetadata(output),
@@ -1674,37 +1100,9 @@ export const de_DescribeDomainConfigCommand = async (output, context) => {
1674
1100
  Object.assign(contents, doc);
1675
1101
  return contents;
1676
1102
  };
1677
- const de_DescribeDomainConfigCommandError = async (output, context) => {
1678
- const parsedOutput = {
1679
- ...output,
1680
- body: await parseErrorBody(output.body, context),
1681
- };
1682
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1683
- switch (errorCode) {
1684
- case "BaseException":
1685
- case "com.amazonaws.opensearch#BaseException":
1686
- throw await de_BaseExceptionRes(parsedOutput, context);
1687
- case "InternalException":
1688
- case "com.amazonaws.opensearch#InternalException":
1689
- throw await de_InternalExceptionRes(parsedOutput, context);
1690
- case "ResourceNotFoundException":
1691
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1692
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1693
- case "ValidationException":
1694
- case "com.amazonaws.opensearch#ValidationException":
1695
- throw await de_ValidationExceptionRes(parsedOutput, context);
1696
- default:
1697
- const parsedBody = parsedOutput.body;
1698
- return throwDefaultError({
1699
- output,
1700
- parsedBody,
1701
- errorCode,
1702
- });
1703
- }
1704
- };
1705
1103
  export const de_DescribeDomainHealthCommand = async (output, context) => {
1706
1104
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1707
- return de_DescribeDomainHealthCommandError(output, context);
1105
+ return de_CommandError(output, context);
1708
1106
  }
1709
1107
  const contents = map({
1710
1108
  $metadata: deserializeMetadata(output),
@@ -1728,40 +1126,9 @@ export const de_DescribeDomainHealthCommand = async (output, context) => {
1728
1126
  Object.assign(contents, doc);
1729
1127
  return contents;
1730
1128
  };
1731
- const de_DescribeDomainHealthCommandError = async (output, context) => {
1732
- const parsedOutput = {
1733
- ...output,
1734
- body: await parseErrorBody(output.body, context),
1735
- };
1736
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1737
- switch (errorCode) {
1738
- case "BaseException":
1739
- case "com.amazonaws.opensearch#BaseException":
1740
- throw await de_BaseExceptionRes(parsedOutput, context);
1741
- case "DisabledOperationException":
1742
- case "com.amazonaws.opensearch#DisabledOperationException":
1743
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1744
- case "InternalException":
1745
- case "com.amazonaws.opensearch#InternalException":
1746
- throw await de_InternalExceptionRes(parsedOutput, context);
1747
- case "ResourceNotFoundException":
1748
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1749
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1750
- case "ValidationException":
1751
- case "com.amazonaws.opensearch#ValidationException":
1752
- throw await de_ValidationExceptionRes(parsedOutput, context);
1753
- default:
1754
- const parsedBody = parsedOutput.body;
1755
- return throwDefaultError({
1756
- output,
1757
- parsedBody,
1758
- errorCode,
1759
- });
1760
- }
1761
- };
1762
1129
  export const de_DescribeDomainNodesCommand = async (output, context) => {
1763
1130
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1764
- return de_DescribeDomainNodesCommandError(output, context);
1131
+ return de_CommandError(output, context);
1765
1132
  }
1766
1133
  const contents = map({
1767
1134
  $metadata: deserializeMetadata(output),
@@ -1773,43 +1140,9 @@ export const de_DescribeDomainNodesCommand = async (output, context) => {
1773
1140
  Object.assign(contents, doc);
1774
1141
  return contents;
1775
1142
  };
1776
- const de_DescribeDomainNodesCommandError = async (output, context) => {
1777
- const parsedOutput = {
1778
- ...output,
1779
- body: await parseErrorBody(output.body, context),
1780
- };
1781
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1782
- switch (errorCode) {
1783
- case "BaseException":
1784
- case "com.amazonaws.opensearch#BaseException":
1785
- throw await de_BaseExceptionRes(parsedOutput, context);
1786
- case "DependencyFailureException":
1787
- case "com.amazonaws.opensearch#DependencyFailureException":
1788
- throw await de_DependencyFailureExceptionRes(parsedOutput, context);
1789
- case "DisabledOperationException":
1790
- case "com.amazonaws.opensearch#DisabledOperationException":
1791
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1792
- case "InternalException":
1793
- case "com.amazonaws.opensearch#InternalException":
1794
- throw await de_InternalExceptionRes(parsedOutput, context);
1795
- case "ResourceNotFoundException":
1796
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1797
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1798
- case "ValidationException":
1799
- case "com.amazonaws.opensearch#ValidationException":
1800
- throw await de_ValidationExceptionRes(parsedOutput, context);
1801
- default:
1802
- const parsedBody = parsedOutput.body;
1803
- return throwDefaultError({
1804
- output,
1805
- parsedBody,
1806
- errorCode,
1807
- });
1808
- }
1809
- };
1810
1143
  export const de_DescribeDomainsCommand = async (output, context) => {
1811
1144
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1812
- return de_DescribeDomainsCommandError(output, context);
1145
+ return de_CommandError(output, context);
1813
1146
  }
1814
1147
  const contents = map({
1815
1148
  $metadata: deserializeMetadata(output),
@@ -1821,34 +1154,9 @@ export const de_DescribeDomainsCommand = async (output, context) => {
1821
1154
  Object.assign(contents, doc);
1822
1155
  return contents;
1823
1156
  };
1824
- const de_DescribeDomainsCommandError = async (output, context) => {
1825
- const parsedOutput = {
1826
- ...output,
1827
- body: await parseErrorBody(output.body, context),
1828
- };
1829
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1830
- switch (errorCode) {
1831
- case "BaseException":
1832
- case "com.amazonaws.opensearch#BaseException":
1833
- throw await de_BaseExceptionRes(parsedOutput, context);
1834
- case "InternalException":
1835
- case "com.amazonaws.opensearch#InternalException":
1836
- throw await de_InternalExceptionRes(parsedOutput, context);
1837
- case "ValidationException":
1838
- case "com.amazonaws.opensearch#ValidationException":
1839
- throw await de_ValidationExceptionRes(parsedOutput, context);
1840
- default:
1841
- const parsedBody = parsedOutput.body;
1842
- return throwDefaultError({
1843
- output,
1844
- parsedBody,
1845
- errorCode,
1846
- });
1847
- }
1848
- };
1849
1157
  export const de_DescribeDryRunProgressCommand = async (output, context) => {
1850
1158
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1851
- return de_DescribeDryRunProgressCommandError(output, context);
1159
+ return de_CommandError(output, context);
1852
1160
  }
1853
1161
  const contents = map({
1854
1162
  $metadata: deserializeMetadata(output),
@@ -1862,40 +1170,9 @@ export const de_DescribeDryRunProgressCommand = async (output, context) => {
1862
1170
  Object.assign(contents, doc);
1863
1171
  return contents;
1864
1172
  };
1865
- const de_DescribeDryRunProgressCommandError = async (output, context) => {
1866
- const parsedOutput = {
1867
- ...output,
1868
- body: await parseErrorBody(output.body, context),
1869
- };
1870
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1871
- switch (errorCode) {
1872
- case "BaseException":
1873
- case "com.amazonaws.opensearch#BaseException":
1874
- throw await de_BaseExceptionRes(parsedOutput, context);
1875
- case "DisabledOperationException":
1876
- case "com.amazonaws.opensearch#DisabledOperationException":
1877
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1878
- case "InternalException":
1879
- case "com.amazonaws.opensearch#InternalException":
1880
- throw await de_InternalExceptionRes(parsedOutput, context);
1881
- case "ResourceNotFoundException":
1882
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1883
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1884
- case "ValidationException":
1885
- case "com.amazonaws.opensearch#ValidationException":
1886
- throw await de_ValidationExceptionRes(parsedOutput, context);
1887
- default:
1888
- const parsedBody = parsedOutput.body;
1889
- return throwDefaultError({
1890
- output,
1891
- parsedBody,
1892
- errorCode,
1893
- });
1894
- }
1895
- };
1896
1173
  export const de_DescribeInboundConnectionsCommand = async (output, context) => {
1897
1174
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1898
- return de_DescribeInboundConnectionsCommandError(output, context);
1175
+ return de_CommandError(output, context);
1899
1176
  }
1900
1177
  const contents = map({
1901
1178
  $metadata: deserializeMetadata(output),
@@ -1908,31 +1185,9 @@ export const de_DescribeInboundConnectionsCommand = async (output, context) => {
1908
1185
  Object.assign(contents, doc);
1909
1186
  return contents;
1910
1187
  };
1911
- const de_DescribeInboundConnectionsCommandError = async (output, context) => {
1912
- const parsedOutput = {
1913
- ...output,
1914
- body: await parseErrorBody(output.body, context),
1915
- };
1916
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1917
- switch (errorCode) {
1918
- case "DisabledOperationException":
1919
- case "com.amazonaws.opensearch#DisabledOperationException":
1920
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
1921
- case "InvalidPaginationTokenException":
1922
- case "com.amazonaws.opensearch#InvalidPaginationTokenException":
1923
- throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
1924
- default:
1925
- const parsedBody = parsedOutput.body;
1926
- return throwDefaultError({
1927
- output,
1928
- parsedBody,
1929
- errorCode,
1930
- });
1931
- }
1932
- };
1933
1188
  export const de_DescribeInstanceTypeLimitsCommand = async (output, context) => {
1934
1189
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1935
- return de_DescribeInstanceTypeLimitsCommandError(output, context);
1190
+ return de_CommandError(output, context);
1936
1191
  }
1937
1192
  const contents = map({
1938
1193
  $metadata: deserializeMetadata(output),
@@ -1944,43 +1199,9 @@ export const de_DescribeInstanceTypeLimitsCommand = async (output, context) => {
1944
1199
  Object.assign(contents, doc);
1945
1200
  return contents;
1946
1201
  };
1947
- const de_DescribeInstanceTypeLimitsCommandError = async (output, context) => {
1948
- const parsedOutput = {
1949
- ...output,
1950
- body: await parseErrorBody(output.body, context),
1951
- };
1952
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1953
- switch (errorCode) {
1954
- case "BaseException":
1955
- case "com.amazonaws.opensearch#BaseException":
1956
- throw await de_BaseExceptionRes(parsedOutput, context);
1957
- case "InternalException":
1958
- case "com.amazonaws.opensearch#InternalException":
1959
- throw await de_InternalExceptionRes(parsedOutput, context);
1960
- case "InvalidTypeException":
1961
- case "com.amazonaws.opensearch#InvalidTypeException":
1962
- throw await de_InvalidTypeExceptionRes(parsedOutput, context);
1963
- case "LimitExceededException":
1964
- case "com.amazonaws.opensearch#LimitExceededException":
1965
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1966
- case "ResourceNotFoundException":
1967
- case "com.amazonaws.opensearch#ResourceNotFoundException":
1968
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1969
- case "ValidationException":
1970
- case "com.amazonaws.opensearch#ValidationException":
1971
- throw await de_ValidationExceptionRes(parsedOutput, context);
1972
- default:
1973
- const parsedBody = parsedOutput.body;
1974
- return throwDefaultError({
1975
- output,
1976
- parsedBody,
1977
- errorCode,
1978
- });
1979
- }
1980
- };
1981
1202
  export const de_DescribeOutboundConnectionsCommand = async (output, context) => {
1982
1203
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1983
- return de_DescribeOutboundConnectionsCommandError(output, context);
1204
+ return de_CommandError(output, context);
1984
1205
  }
1985
1206
  const contents = map({
1986
1207
  $metadata: deserializeMetadata(output),
@@ -1993,31 +1214,9 @@ export const de_DescribeOutboundConnectionsCommand = async (output, context) =>
1993
1214
  Object.assign(contents, doc);
1994
1215
  return contents;
1995
1216
  };
1996
- const de_DescribeOutboundConnectionsCommandError = async (output, context) => {
1997
- const parsedOutput = {
1998
- ...output,
1999
- body: await parseErrorBody(output.body, context),
2000
- };
2001
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2002
- switch (errorCode) {
2003
- case "DisabledOperationException":
2004
- case "com.amazonaws.opensearch#DisabledOperationException":
2005
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2006
- case "InvalidPaginationTokenException":
2007
- case "com.amazonaws.opensearch#InvalidPaginationTokenException":
2008
- throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
2009
- default:
2010
- const parsedBody = parsedOutput.body;
2011
- return throwDefaultError({
2012
- output,
2013
- parsedBody,
2014
- errorCode,
2015
- });
2016
- }
2017
- };
2018
1217
  export const de_DescribePackagesCommand = async (output, context) => {
2019
1218
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2020
- return de_DescribePackagesCommandError(output, context);
1219
+ return de_CommandError(output, context);
2021
1220
  }
2022
1221
  const contents = map({
2023
1222
  $metadata: deserializeMetadata(output),
@@ -2030,40 +1229,9 @@ export const de_DescribePackagesCommand = async (output, context) => {
2030
1229
  Object.assign(contents, doc);
2031
1230
  return contents;
2032
1231
  };
2033
- const de_DescribePackagesCommandError = async (output, context) => {
2034
- const parsedOutput = {
2035
- ...output,
2036
- body: await parseErrorBody(output.body, context),
2037
- };
2038
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2039
- switch (errorCode) {
2040
- case "AccessDeniedException":
2041
- case "com.amazonaws.opensearch#AccessDeniedException":
2042
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2043
- case "BaseException":
2044
- case "com.amazonaws.opensearch#BaseException":
2045
- throw await de_BaseExceptionRes(parsedOutput, context);
2046
- case "InternalException":
2047
- case "com.amazonaws.opensearch#InternalException":
2048
- throw await de_InternalExceptionRes(parsedOutput, context);
2049
- case "ResourceNotFoundException":
2050
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2051
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2052
- case "ValidationException":
2053
- case "com.amazonaws.opensearch#ValidationException":
2054
- throw await de_ValidationExceptionRes(parsedOutput, context);
2055
- default:
2056
- const parsedBody = parsedOutput.body;
2057
- return throwDefaultError({
2058
- output,
2059
- parsedBody,
2060
- errorCode,
2061
- });
2062
- }
2063
- };
2064
1232
  export const de_DescribeReservedInstanceOfferingsCommand = async (output, context) => {
2065
1233
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2066
- return de_DescribeReservedInstanceOfferingsCommandError(output, context);
1234
+ return de_CommandError(output, context);
2067
1235
  }
2068
1236
  const contents = map({
2069
1237
  $metadata: deserializeMetadata(output),
@@ -2076,37 +1244,9 @@ export const de_DescribeReservedInstanceOfferingsCommand = async (output, contex
2076
1244
  Object.assign(contents, doc);
2077
1245
  return contents;
2078
1246
  };
2079
- const de_DescribeReservedInstanceOfferingsCommandError = async (output, context) => {
2080
- const parsedOutput = {
2081
- ...output,
2082
- body: await parseErrorBody(output.body, context),
2083
- };
2084
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2085
- switch (errorCode) {
2086
- case "DisabledOperationException":
2087
- case "com.amazonaws.opensearch#DisabledOperationException":
2088
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2089
- case "InternalException":
2090
- case "com.amazonaws.opensearch#InternalException":
2091
- throw await de_InternalExceptionRes(parsedOutput, context);
2092
- case "ResourceNotFoundException":
2093
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2094
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2095
- case "ValidationException":
2096
- case "com.amazonaws.opensearch#ValidationException":
2097
- throw await de_ValidationExceptionRes(parsedOutput, context);
2098
- default:
2099
- const parsedBody = parsedOutput.body;
2100
- return throwDefaultError({
2101
- output,
2102
- parsedBody,
2103
- errorCode,
2104
- });
2105
- }
2106
- };
2107
1247
  export const de_DescribeReservedInstancesCommand = async (output, context) => {
2108
1248
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2109
- return de_DescribeReservedInstancesCommandError(output, context);
1249
+ return de_CommandError(output, context);
2110
1250
  }
2111
1251
  const contents = map({
2112
1252
  $metadata: deserializeMetadata(output),
@@ -2119,37 +1259,9 @@ export const de_DescribeReservedInstancesCommand = async (output, context) => {
2119
1259
  Object.assign(contents, doc);
2120
1260
  return contents;
2121
1261
  };
2122
- const de_DescribeReservedInstancesCommandError = async (output, context) => {
2123
- const parsedOutput = {
2124
- ...output,
2125
- body: await parseErrorBody(output.body, context),
2126
- };
2127
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2128
- switch (errorCode) {
2129
- case "DisabledOperationException":
2130
- case "com.amazonaws.opensearch#DisabledOperationException":
2131
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2132
- case "InternalException":
2133
- case "com.amazonaws.opensearch#InternalException":
2134
- throw await de_InternalExceptionRes(parsedOutput, context);
2135
- case "ResourceNotFoundException":
2136
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2137
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2138
- case "ValidationException":
2139
- case "com.amazonaws.opensearch#ValidationException":
2140
- throw await de_ValidationExceptionRes(parsedOutput, context);
2141
- default:
2142
- const parsedBody = parsedOutput.body;
2143
- return throwDefaultError({
2144
- output,
2145
- parsedBody,
2146
- errorCode,
2147
- });
2148
- }
2149
- };
2150
1262
  export const de_DescribeVpcEndpointsCommand = async (output, context) => {
2151
1263
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2152
- return de_DescribeVpcEndpointsCommandError(output, context);
1264
+ return de_CommandError(output, context);
2153
1265
  }
2154
1266
  const contents = map({
2155
1267
  $metadata: deserializeMetadata(output),
@@ -2162,37 +1274,9 @@ export const de_DescribeVpcEndpointsCommand = async (output, context) => {
2162
1274
  Object.assign(contents, doc);
2163
1275
  return contents;
2164
1276
  };
2165
- const de_DescribeVpcEndpointsCommandError = async (output, context) => {
2166
- const parsedOutput = {
2167
- ...output,
2168
- body: await parseErrorBody(output.body, context),
2169
- };
2170
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2171
- switch (errorCode) {
2172
- case "BaseException":
2173
- case "com.amazonaws.opensearch#BaseException":
2174
- throw await de_BaseExceptionRes(parsedOutput, context);
2175
- case "DisabledOperationException":
2176
- case "com.amazonaws.opensearch#DisabledOperationException":
2177
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2178
- case "InternalException":
2179
- case "com.amazonaws.opensearch#InternalException":
2180
- throw await de_InternalExceptionRes(parsedOutput, context);
2181
- case "ValidationException":
2182
- case "com.amazonaws.opensearch#ValidationException":
2183
- throw await de_ValidationExceptionRes(parsedOutput, context);
2184
- default:
2185
- const parsedBody = parsedOutput.body;
2186
- return throwDefaultError({
2187
- output,
2188
- parsedBody,
2189
- errorCode,
2190
- });
2191
- }
2192
- };
2193
1277
  export const de_DissociatePackageCommand = async (output, context) => {
2194
1278
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2195
- return de_DissociatePackageCommandError(output, context);
1279
+ return de_CommandError(output, context);
2196
1280
  }
2197
1281
  const contents = map({
2198
1282
  $metadata: deserializeMetadata(output),
@@ -2204,43 +1288,9 @@ export const de_DissociatePackageCommand = async (output, context) => {
2204
1288
  Object.assign(contents, doc);
2205
1289
  return contents;
2206
1290
  };
2207
- const de_DissociatePackageCommandError = async (output, context) => {
2208
- const parsedOutput = {
2209
- ...output,
2210
- body: await parseErrorBody(output.body, context),
2211
- };
2212
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2213
- switch (errorCode) {
2214
- case "AccessDeniedException":
2215
- case "com.amazonaws.opensearch#AccessDeniedException":
2216
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2217
- case "BaseException":
2218
- case "com.amazonaws.opensearch#BaseException":
2219
- throw await de_BaseExceptionRes(parsedOutput, context);
2220
- case "ConflictException":
2221
- case "com.amazonaws.opensearch#ConflictException":
2222
- throw await de_ConflictExceptionRes(parsedOutput, context);
2223
- case "InternalException":
2224
- case "com.amazonaws.opensearch#InternalException":
2225
- throw await de_InternalExceptionRes(parsedOutput, context);
2226
- case "ResourceNotFoundException":
2227
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2228
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2229
- case "ValidationException":
2230
- case "com.amazonaws.opensearch#ValidationException":
2231
- throw await de_ValidationExceptionRes(parsedOutput, context);
2232
- default:
2233
- const parsedBody = parsedOutput.body;
2234
- return throwDefaultError({
2235
- output,
2236
- parsedBody,
2237
- errorCode,
2238
- });
2239
- }
2240
- };
2241
1291
  export const de_GetCompatibleVersionsCommand = async (output, context) => {
2242
1292
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2243
- return de_GetCompatibleVersionsCommandError(output, context);
1293
+ return de_CommandError(output, context);
2244
1294
  }
2245
1295
  const contents = map({
2246
1296
  $metadata: deserializeMetadata(output),
@@ -2252,40 +1302,9 @@ export const de_GetCompatibleVersionsCommand = async (output, context) => {
2252
1302
  Object.assign(contents, doc);
2253
1303
  return contents;
2254
1304
  };
2255
- const de_GetCompatibleVersionsCommandError = async (output, context) => {
2256
- const parsedOutput = {
2257
- ...output,
2258
- body: await parseErrorBody(output.body, context),
2259
- };
2260
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2261
- switch (errorCode) {
2262
- case "BaseException":
2263
- case "com.amazonaws.opensearch#BaseException":
2264
- throw await de_BaseExceptionRes(parsedOutput, context);
2265
- case "DisabledOperationException":
2266
- case "com.amazonaws.opensearch#DisabledOperationException":
2267
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2268
- case "InternalException":
2269
- case "com.amazonaws.opensearch#InternalException":
2270
- throw await de_InternalExceptionRes(parsedOutput, context);
2271
- case "ResourceNotFoundException":
2272
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2273
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2274
- case "ValidationException":
2275
- case "com.amazonaws.opensearch#ValidationException":
2276
- throw await de_ValidationExceptionRes(parsedOutput, context);
2277
- default:
2278
- const parsedBody = parsedOutput.body;
2279
- return throwDefaultError({
2280
- output,
2281
- parsedBody,
2282
- errorCode,
2283
- });
2284
- }
2285
- };
2286
1305
  export const de_GetDataSourceCommand = async (output, context) => {
2287
1306
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2288
- return de_GetDataSourceCommandError(output, context);
1307
+ return de_CommandError(output, context);
2289
1308
  }
2290
1309
  const contents = map({
2291
1310
  $metadata: deserializeMetadata(output),
@@ -2299,43 +1318,9 @@ export const de_GetDataSourceCommand = async (output, context) => {
2299
1318
  Object.assign(contents, doc);
2300
1319
  return contents;
2301
1320
  };
2302
- const de_GetDataSourceCommandError = async (output, context) => {
2303
- const parsedOutput = {
2304
- ...output,
2305
- body: await parseErrorBody(output.body, context),
2306
- };
2307
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2308
- switch (errorCode) {
2309
- case "BaseException":
2310
- case "com.amazonaws.opensearch#BaseException":
2311
- throw await de_BaseExceptionRes(parsedOutput, context);
2312
- case "DependencyFailureException":
2313
- case "com.amazonaws.opensearch#DependencyFailureException":
2314
- throw await de_DependencyFailureExceptionRes(parsedOutput, context);
2315
- case "DisabledOperationException":
2316
- case "com.amazonaws.opensearch#DisabledOperationException":
2317
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2318
- case "InternalException":
2319
- case "com.amazonaws.opensearch#InternalException":
2320
- throw await de_InternalExceptionRes(parsedOutput, context);
2321
- case "ResourceNotFoundException":
2322
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2323
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2324
- case "ValidationException":
2325
- case "com.amazonaws.opensearch#ValidationException":
2326
- throw await de_ValidationExceptionRes(parsedOutput, context);
2327
- default:
2328
- const parsedBody = parsedOutput.body;
2329
- return throwDefaultError({
2330
- output,
2331
- parsedBody,
2332
- errorCode,
2333
- });
2334
- }
2335
- };
2336
1321
  export const de_GetDomainMaintenanceStatusCommand = async (output, context) => {
2337
1322
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2338
- return de_GetDomainMaintenanceStatusCommandError(output, context);
1323
+ return de_CommandError(output, context);
2339
1324
  }
2340
1325
  const contents = map({
2341
1326
  $metadata: deserializeMetadata(output),
@@ -2352,40 +1337,9 @@ export const de_GetDomainMaintenanceStatusCommand = async (output, context) => {
2352
1337
  Object.assign(contents, doc);
2353
1338
  return contents;
2354
1339
  };
2355
- const de_GetDomainMaintenanceStatusCommandError = async (output, context) => {
2356
- const parsedOutput = {
2357
- ...output,
2358
- body: await parseErrorBody(output.body, context),
2359
- };
2360
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2361
- switch (errorCode) {
2362
- case "BaseException":
2363
- case "com.amazonaws.opensearch#BaseException":
2364
- throw await de_BaseExceptionRes(parsedOutput, context);
2365
- case "DisabledOperationException":
2366
- case "com.amazonaws.opensearch#DisabledOperationException":
2367
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2368
- case "InternalException":
2369
- case "com.amazonaws.opensearch#InternalException":
2370
- throw await de_InternalExceptionRes(parsedOutput, context);
2371
- case "ResourceNotFoundException":
2372
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2373
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2374
- case "ValidationException":
2375
- case "com.amazonaws.opensearch#ValidationException":
2376
- throw await de_ValidationExceptionRes(parsedOutput, context);
2377
- default:
2378
- const parsedBody = parsedOutput.body;
2379
- return throwDefaultError({
2380
- output,
2381
- parsedBody,
2382
- errorCode,
2383
- });
2384
- }
2385
- };
2386
1340
  export const de_GetPackageVersionHistoryCommand = async (output, context) => {
2387
1341
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2388
- return de_GetPackageVersionHistoryCommandError(output, context);
1342
+ return de_CommandError(output, context);
2389
1343
  }
2390
1344
  const contents = map({
2391
1345
  $metadata: deserializeMetadata(output),
@@ -2399,40 +1353,9 @@ export const de_GetPackageVersionHistoryCommand = async (output, context) => {
2399
1353
  Object.assign(contents, doc);
2400
1354
  return contents;
2401
1355
  };
2402
- const de_GetPackageVersionHistoryCommandError = async (output, context) => {
2403
- const parsedOutput = {
2404
- ...output,
2405
- body: await parseErrorBody(output.body, context),
2406
- };
2407
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2408
- switch (errorCode) {
2409
- case "AccessDeniedException":
2410
- case "com.amazonaws.opensearch#AccessDeniedException":
2411
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2412
- case "BaseException":
2413
- case "com.amazonaws.opensearch#BaseException":
2414
- throw await de_BaseExceptionRes(parsedOutput, context);
2415
- case "InternalException":
2416
- case "com.amazonaws.opensearch#InternalException":
2417
- throw await de_InternalExceptionRes(parsedOutput, context);
2418
- case "ResourceNotFoundException":
2419
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2420
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2421
- case "ValidationException":
2422
- case "com.amazonaws.opensearch#ValidationException":
2423
- throw await de_ValidationExceptionRes(parsedOutput, context);
2424
- default:
2425
- const parsedBody = parsedOutput.body;
2426
- return throwDefaultError({
2427
- output,
2428
- parsedBody,
2429
- errorCode,
2430
- });
2431
- }
2432
- };
2433
1356
  export const de_GetUpgradeHistoryCommand = async (output, context) => {
2434
1357
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2435
- return de_GetUpgradeHistoryCommandError(output, context);
1358
+ return de_CommandError(output, context);
2436
1359
  }
2437
1360
  const contents = map({
2438
1361
  $metadata: deserializeMetadata(output),
@@ -2445,40 +1368,9 @@ export const de_GetUpgradeHistoryCommand = async (output, context) => {
2445
1368
  Object.assign(contents, doc);
2446
1369
  return contents;
2447
1370
  };
2448
- const de_GetUpgradeHistoryCommandError = async (output, context) => {
2449
- const parsedOutput = {
2450
- ...output,
2451
- body: await parseErrorBody(output.body, context),
2452
- };
2453
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2454
- switch (errorCode) {
2455
- case "BaseException":
2456
- case "com.amazonaws.opensearch#BaseException":
2457
- throw await de_BaseExceptionRes(parsedOutput, context);
2458
- case "DisabledOperationException":
2459
- case "com.amazonaws.opensearch#DisabledOperationException":
2460
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2461
- case "InternalException":
2462
- case "com.amazonaws.opensearch#InternalException":
2463
- throw await de_InternalExceptionRes(parsedOutput, context);
2464
- case "ResourceNotFoundException":
2465
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2466
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2467
- case "ValidationException":
2468
- case "com.amazonaws.opensearch#ValidationException":
2469
- throw await de_ValidationExceptionRes(parsedOutput, context);
2470
- default:
2471
- const parsedBody = parsedOutput.body;
2472
- return throwDefaultError({
2473
- output,
2474
- parsedBody,
2475
- errorCode,
2476
- });
2477
- }
2478
- };
2479
1371
  export const de_GetUpgradeStatusCommand = async (output, context) => {
2480
1372
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2481
- return de_GetUpgradeStatusCommandError(output, context);
1373
+ return de_CommandError(output, context);
2482
1374
  }
2483
1375
  const contents = map({
2484
1376
  $metadata: deserializeMetadata(output),
@@ -2492,40 +1384,9 @@ export const de_GetUpgradeStatusCommand = async (output, context) => {
2492
1384
  Object.assign(contents, doc);
2493
1385
  return contents;
2494
1386
  };
2495
- const de_GetUpgradeStatusCommandError = async (output, context) => {
2496
- const parsedOutput = {
2497
- ...output,
2498
- body: await parseErrorBody(output.body, context),
2499
- };
2500
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2501
- switch (errorCode) {
2502
- case "BaseException":
2503
- case "com.amazonaws.opensearch#BaseException":
2504
- throw await de_BaseExceptionRes(parsedOutput, context);
2505
- case "DisabledOperationException":
2506
- case "com.amazonaws.opensearch#DisabledOperationException":
2507
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2508
- case "InternalException":
2509
- case "com.amazonaws.opensearch#InternalException":
2510
- throw await de_InternalExceptionRes(parsedOutput, context);
2511
- case "ResourceNotFoundException":
2512
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2513
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2514
- case "ValidationException":
2515
- case "com.amazonaws.opensearch#ValidationException":
2516
- throw await de_ValidationExceptionRes(parsedOutput, context);
2517
- default:
2518
- const parsedBody = parsedOutput.body;
2519
- return throwDefaultError({
2520
- output,
2521
- parsedBody,
2522
- errorCode,
2523
- });
2524
- }
2525
- };
2526
1387
  export const de_ListDataSourcesCommand = async (output, context) => {
2527
1388
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2528
- return de_ListDataSourcesCommandError(output, context);
1389
+ return de_CommandError(output, context);
2529
1390
  }
2530
1391
  const contents = map({
2531
1392
  $metadata: deserializeMetadata(output),
@@ -2537,43 +1398,9 @@ export const de_ListDataSourcesCommand = async (output, context) => {
2537
1398
  Object.assign(contents, doc);
2538
1399
  return contents;
2539
1400
  };
2540
- const de_ListDataSourcesCommandError = async (output, context) => {
2541
- const parsedOutput = {
2542
- ...output,
2543
- body: await parseErrorBody(output.body, context),
2544
- };
2545
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2546
- switch (errorCode) {
2547
- case "BaseException":
2548
- case "com.amazonaws.opensearch#BaseException":
2549
- throw await de_BaseExceptionRes(parsedOutput, context);
2550
- case "DependencyFailureException":
2551
- case "com.amazonaws.opensearch#DependencyFailureException":
2552
- throw await de_DependencyFailureExceptionRes(parsedOutput, context);
2553
- case "DisabledOperationException":
2554
- case "com.amazonaws.opensearch#DisabledOperationException":
2555
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2556
- case "InternalException":
2557
- case "com.amazonaws.opensearch#InternalException":
2558
- throw await de_InternalExceptionRes(parsedOutput, context);
2559
- case "ResourceNotFoundException":
2560
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2561
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2562
- case "ValidationException":
2563
- case "com.amazonaws.opensearch#ValidationException":
2564
- throw await de_ValidationExceptionRes(parsedOutput, context);
2565
- default:
2566
- const parsedBody = parsedOutput.body;
2567
- return throwDefaultError({
2568
- output,
2569
- parsedBody,
2570
- errorCode,
2571
- });
2572
- }
2573
- };
2574
1401
  export const de_ListDomainMaintenancesCommand = async (output, context) => {
2575
1402
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2576
- return de_ListDomainMaintenancesCommandError(output, context);
1403
+ return de_CommandError(output, context);
2577
1404
  }
2578
1405
  const contents = map({
2579
1406
  $metadata: deserializeMetadata(output),
@@ -2586,40 +1413,9 @@ export const de_ListDomainMaintenancesCommand = async (output, context) => {
2586
1413
  Object.assign(contents, doc);
2587
1414
  return contents;
2588
1415
  };
2589
- const de_ListDomainMaintenancesCommandError = async (output, context) => {
2590
- const parsedOutput = {
2591
- ...output,
2592
- body: await parseErrorBody(output.body, context),
2593
- };
2594
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2595
- switch (errorCode) {
2596
- case "BaseException":
2597
- case "com.amazonaws.opensearch#BaseException":
2598
- throw await de_BaseExceptionRes(parsedOutput, context);
2599
- case "DisabledOperationException":
2600
- case "com.amazonaws.opensearch#DisabledOperationException":
2601
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2602
- case "InternalException":
2603
- case "com.amazonaws.opensearch#InternalException":
2604
- throw await de_InternalExceptionRes(parsedOutput, context);
2605
- case "ResourceNotFoundException":
2606
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2607
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2608
- case "ValidationException":
2609
- case "com.amazonaws.opensearch#ValidationException":
2610
- throw await de_ValidationExceptionRes(parsedOutput, context);
2611
- default:
2612
- const parsedBody = parsedOutput.body;
2613
- return throwDefaultError({
2614
- output,
2615
- parsedBody,
2616
- errorCode,
2617
- });
2618
- }
2619
- };
2620
1416
  export const de_ListDomainNamesCommand = async (output, context) => {
2621
1417
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2622
- return de_ListDomainNamesCommandError(output, context);
1418
+ return de_CommandError(output, context);
2623
1419
  }
2624
1420
  const contents = map({
2625
1421
  $metadata: deserializeMetadata(output),
@@ -2631,31 +1427,9 @@ export const de_ListDomainNamesCommand = async (output, context) => {
2631
1427
  Object.assign(contents, doc);
2632
1428
  return contents;
2633
1429
  };
2634
- const de_ListDomainNamesCommandError = async (output, context) => {
2635
- const parsedOutput = {
2636
- ...output,
2637
- body: await parseErrorBody(output.body, context),
2638
- };
2639
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2640
- switch (errorCode) {
2641
- case "BaseException":
2642
- case "com.amazonaws.opensearch#BaseException":
2643
- throw await de_BaseExceptionRes(parsedOutput, context);
2644
- case "ValidationException":
2645
- case "com.amazonaws.opensearch#ValidationException":
2646
- throw await de_ValidationExceptionRes(parsedOutput, context);
2647
- default:
2648
- const parsedBody = parsedOutput.body;
2649
- return throwDefaultError({
2650
- output,
2651
- parsedBody,
2652
- errorCode,
2653
- });
2654
- }
2655
- };
2656
1430
  export const de_ListDomainsForPackageCommand = async (output, context) => {
2657
1431
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2658
- return de_ListDomainsForPackageCommandError(output, context);
1432
+ return de_CommandError(output, context);
2659
1433
  }
2660
1434
  const contents = map({
2661
1435
  $metadata: deserializeMetadata(output),
@@ -2668,40 +1442,9 @@ export const de_ListDomainsForPackageCommand = async (output, context) => {
2668
1442
  Object.assign(contents, doc);
2669
1443
  return contents;
2670
1444
  };
2671
- const de_ListDomainsForPackageCommandError = async (output, context) => {
2672
- const parsedOutput = {
2673
- ...output,
2674
- body: await parseErrorBody(output.body, context),
2675
- };
2676
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2677
- switch (errorCode) {
2678
- case "AccessDeniedException":
2679
- case "com.amazonaws.opensearch#AccessDeniedException":
2680
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2681
- case "BaseException":
2682
- case "com.amazonaws.opensearch#BaseException":
2683
- throw await de_BaseExceptionRes(parsedOutput, context);
2684
- case "InternalException":
2685
- case "com.amazonaws.opensearch#InternalException":
2686
- throw await de_InternalExceptionRes(parsedOutput, context);
2687
- case "ResourceNotFoundException":
2688
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2689
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2690
- case "ValidationException":
2691
- case "com.amazonaws.opensearch#ValidationException":
2692
- throw await de_ValidationExceptionRes(parsedOutput, context);
2693
- default:
2694
- const parsedBody = parsedOutput.body;
2695
- return throwDefaultError({
2696
- output,
2697
- parsedBody,
2698
- errorCode,
2699
- });
2700
- }
2701
- };
2702
1445
  export const de_ListInstanceTypeDetailsCommand = async (output, context) => {
2703
1446
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2704
- return de_ListInstanceTypeDetailsCommandError(output, context);
1447
+ return de_CommandError(output, context);
2705
1448
  }
2706
1449
  const contents = map({
2707
1450
  $metadata: deserializeMetadata(output),
@@ -2714,37 +1457,9 @@ export const de_ListInstanceTypeDetailsCommand = async (output, context) => {
2714
1457
  Object.assign(contents, doc);
2715
1458
  return contents;
2716
1459
  };
2717
- const de_ListInstanceTypeDetailsCommandError = async (output, context) => {
2718
- const parsedOutput = {
2719
- ...output,
2720
- body: await parseErrorBody(output.body, context),
2721
- };
2722
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2723
- switch (errorCode) {
2724
- case "BaseException":
2725
- case "com.amazonaws.opensearch#BaseException":
2726
- throw await de_BaseExceptionRes(parsedOutput, context);
2727
- case "InternalException":
2728
- case "com.amazonaws.opensearch#InternalException":
2729
- throw await de_InternalExceptionRes(parsedOutput, context);
2730
- case "ResourceNotFoundException":
2731
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2732
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2733
- case "ValidationException":
2734
- case "com.amazonaws.opensearch#ValidationException":
2735
- throw await de_ValidationExceptionRes(parsedOutput, context);
2736
- default:
2737
- const parsedBody = parsedOutput.body;
2738
- return throwDefaultError({
2739
- output,
2740
- parsedBody,
2741
- errorCode,
2742
- });
2743
- }
2744
- };
2745
1460
  export const de_ListPackagesForDomainCommand = async (output, context) => {
2746
1461
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2747
- return de_ListPackagesForDomainCommandError(output, context);
1462
+ return de_CommandError(output, context);
2748
1463
  }
2749
1464
  const contents = map({
2750
1465
  $metadata: deserializeMetadata(output),
@@ -2757,40 +1472,9 @@ export const de_ListPackagesForDomainCommand = async (output, context) => {
2757
1472
  Object.assign(contents, doc);
2758
1473
  return contents;
2759
1474
  };
2760
- const de_ListPackagesForDomainCommandError = async (output, context) => {
2761
- const parsedOutput = {
2762
- ...output,
2763
- body: await parseErrorBody(output.body, context),
2764
- };
2765
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2766
- switch (errorCode) {
2767
- case "AccessDeniedException":
2768
- case "com.amazonaws.opensearch#AccessDeniedException":
2769
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2770
- case "BaseException":
2771
- case "com.amazonaws.opensearch#BaseException":
2772
- throw await de_BaseExceptionRes(parsedOutput, context);
2773
- case "InternalException":
2774
- case "com.amazonaws.opensearch#InternalException":
2775
- throw await de_InternalExceptionRes(parsedOutput, context);
2776
- case "ResourceNotFoundException":
2777
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2778
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2779
- case "ValidationException":
2780
- case "com.amazonaws.opensearch#ValidationException":
2781
- throw await de_ValidationExceptionRes(parsedOutput, context);
2782
- default:
2783
- const parsedBody = parsedOutput.body;
2784
- return throwDefaultError({
2785
- output,
2786
- parsedBody,
2787
- errorCode,
2788
- });
2789
- }
2790
- };
2791
1475
  export const de_ListScheduledActionsCommand = async (output, context) => {
2792
1476
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2793
- return de_ListScheduledActionsCommandError(output, context);
1477
+ return de_CommandError(output, context);
2794
1478
  }
2795
1479
  const contents = map({
2796
1480
  $metadata: deserializeMetadata(output),
@@ -2803,40 +1487,9 @@ export const de_ListScheduledActionsCommand = async (output, context) => {
2803
1487
  Object.assign(contents, doc);
2804
1488
  return contents;
2805
1489
  };
2806
- const de_ListScheduledActionsCommandError = async (output, context) => {
2807
- const parsedOutput = {
2808
- ...output,
2809
- body: await parseErrorBody(output.body, context),
2810
- };
2811
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2812
- switch (errorCode) {
2813
- case "BaseException":
2814
- case "com.amazonaws.opensearch#BaseException":
2815
- throw await de_BaseExceptionRes(parsedOutput, context);
2816
- case "InternalException":
2817
- case "com.amazonaws.opensearch#InternalException":
2818
- throw await de_InternalExceptionRes(parsedOutput, context);
2819
- case "InvalidPaginationTokenException":
2820
- case "com.amazonaws.opensearch#InvalidPaginationTokenException":
2821
- throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
2822
- case "ResourceNotFoundException":
2823
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2824
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2825
- case "ValidationException":
2826
- case "com.amazonaws.opensearch#ValidationException":
2827
- throw await de_ValidationExceptionRes(parsedOutput, context);
2828
- default:
2829
- const parsedBody = parsedOutput.body;
2830
- return throwDefaultError({
2831
- output,
2832
- parsedBody,
2833
- errorCode,
2834
- });
2835
- }
2836
- };
2837
1490
  export const de_ListTagsCommand = async (output, context) => {
2838
1491
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2839
- return de_ListTagsCommandError(output, context);
1492
+ return de_CommandError(output, context);
2840
1493
  }
2841
1494
  const contents = map({
2842
1495
  $metadata: deserializeMetadata(output),
@@ -2848,37 +1501,9 @@ export const de_ListTagsCommand = async (output, context) => {
2848
1501
  Object.assign(contents, doc);
2849
1502
  return contents;
2850
1503
  };
2851
- const de_ListTagsCommandError = async (output, context) => {
2852
- const parsedOutput = {
2853
- ...output,
2854
- body: await parseErrorBody(output.body, context),
2855
- };
2856
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2857
- switch (errorCode) {
2858
- case "BaseException":
2859
- case "com.amazonaws.opensearch#BaseException":
2860
- throw await de_BaseExceptionRes(parsedOutput, context);
2861
- case "InternalException":
2862
- case "com.amazonaws.opensearch#InternalException":
2863
- throw await de_InternalExceptionRes(parsedOutput, context);
2864
- case "ResourceNotFoundException":
2865
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2866
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2867
- case "ValidationException":
2868
- case "com.amazonaws.opensearch#ValidationException":
2869
- throw await de_ValidationExceptionRes(parsedOutput, context);
2870
- default:
2871
- const parsedBody = parsedOutput.body;
2872
- return throwDefaultError({
2873
- output,
2874
- parsedBody,
2875
- errorCode,
2876
- });
2877
- }
2878
- };
2879
1504
  export const de_ListVersionsCommand = async (output, context) => {
2880
1505
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2881
- return de_ListVersionsCommandError(output, context);
1506
+ return de_CommandError(output, context);
2882
1507
  }
2883
1508
  const contents = map({
2884
1509
  $metadata: deserializeMetadata(output),
@@ -2891,37 +1516,9 @@ export const de_ListVersionsCommand = async (output, context) => {
2891
1516
  Object.assign(contents, doc);
2892
1517
  return contents;
2893
1518
  };
2894
- const de_ListVersionsCommandError = async (output, context) => {
2895
- const parsedOutput = {
2896
- ...output,
2897
- body: await parseErrorBody(output.body, context),
2898
- };
2899
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2900
- switch (errorCode) {
2901
- case "BaseException":
2902
- case "com.amazonaws.opensearch#BaseException":
2903
- throw await de_BaseExceptionRes(parsedOutput, context);
2904
- case "InternalException":
2905
- case "com.amazonaws.opensearch#InternalException":
2906
- throw await de_InternalExceptionRes(parsedOutput, context);
2907
- case "ResourceNotFoundException":
2908
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2909
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2910
- case "ValidationException":
2911
- case "com.amazonaws.opensearch#ValidationException":
2912
- throw await de_ValidationExceptionRes(parsedOutput, context);
2913
- default:
2914
- const parsedBody = parsedOutput.body;
2915
- return throwDefaultError({
2916
- output,
2917
- parsedBody,
2918
- errorCode,
2919
- });
2920
- }
2921
- };
2922
1519
  export const de_ListVpcEndpointAccessCommand = async (output, context) => {
2923
1520
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2924
- return de_ListVpcEndpointAccessCommandError(output, context);
1521
+ return de_CommandError(output, context);
2925
1522
  }
2926
1523
  const contents = map({
2927
1524
  $metadata: deserializeMetadata(output),
@@ -2934,37 +1531,9 @@ export const de_ListVpcEndpointAccessCommand = async (output, context) => {
2934
1531
  Object.assign(contents, doc);
2935
1532
  return contents;
2936
1533
  };
2937
- const de_ListVpcEndpointAccessCommandError = async (output, context) => {
2938
- const parsedOutput = {
2939
- ...output,
2940
- body: await parseErrorBody(output.body, context),
2941
- };
2942
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2943
- switch (errorCode) {
2944
- case "BaseException":
2945
- case "com.amazonaws.opensearch#BaseException":
2946
- throw await de_BaseExceptionRes(parsedOutput, context);
2947
- case "DisabledOperationException":
2948
- case "com.amazonaws.opensearch#DisabledOperationException":
2949
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2950
- case "InternalException":
2951
- case "com.amazonaws.opensearch#InternalException":
2952
- throw await de_InternalExceptionRes(parsedOutput, context);
2953
- case "ResourceNotFoundException":
2954
- case "com.amazonaws.opensearch#ResourceNotFoundException":
2955
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2956
- default:
2957
- const parsedBody = parsedOutput.body;
2958
- return throwDefaultError({
2959
- output,
2960
- parsedBody,
2961
- errorCode,
2962
- });
2963
- }
2964
- };
2965
1534
  export const de_ListVpcEndpointsCommand = async (output, context) => {
2966
1535
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2967
- return de_ListVpcEndpointsCommandError(output, context);
1536
+ return de_CommandError(output, context);
2968
1537
  }
2969
1538
  const contents = map({
2970
1539
  $metadata: deserializeMetadata(output),
@@ -2977,34 +1546,9 @@ export const de_ListVpcEndpointsCommand = async (output, context) => {
2977
1546
  Object.assign(contents, doc);
2978
1547
  return contents;
2979
1548
  };
2980
- const de_ListVpcEndpointsCommandError = async (output, context) => {
2981
- const parsedOutput = {
2982
- ...output,
2983
- body: await parseErrorBody(output.body, context),
2984
- };
2985
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2986
- switch (errorCode) {
2987
- case "BaseException":
2988
- case "com.amazonaws.opensearch#BaseException":
2989
- throw await de_BaseExceptionRes(parsedOutput, context);
2990
- case "DisabledOperationException":
2991
- case "com.amazonaws.opensearch#DisabledOperationException":
2992
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
2993
- case "InternalException":
2994
- case "com.amazonaws.opensearch#InternalException":
2995
- throw await de_InternalExceptionRes(parsedOutput, context);
2996
- default:
2997
- const parsedBody = parsedOutput.body;
2998
- return throwDefaultError({
2999
- output,
3000
- parsedBody,
3001
- errorCode,
3002
- });
3003
- }
3004
- };
3005
1549
  export const de_ListVpcEndpointsForDomainCommand = async (output, context) => {
3006
1550
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3007
- return de_ListVpcEndpointsForDomainCommandError(output, context);
1551
+ return de_CommandError(output, context);
3008
1552
  }
3009
1553
  const contents = map({
3010
1554
  $metadata: deserializeMetadata(output),
@@ -3017,37 +1561,9 @@ export const de_ListVpcEndpointsForDomainCommand = async (output, context) => {
3017
1561
  Object.assign(contents, doc);
3018
1562
  return contents;
3019
1563
  };
3020
- const de_ListVpcEndpointsForDomainCommandError = async (output, context) => {
3021
- const parsedOutput = {
3022
- ...output,
3023
- body: await parseErrorBody(output.body, context),
3024
- };
3025
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3026
- switch (errorCode) {
3027
- case "BaseException":
3028
- case "com.amazonaws.opensearch#BaseException":
3029
- throw await de_BaseExceptionRes(parsedOutput, context);
3030
- case "DisabledOperationException":
3031
- case "com.amazonaws.opensearch#DisabledOperationException":
3032
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
3033
- case "InternalException":
3034
- case "com.amazonaws.opensearch#InternalException":
3035
- throw await de_InternalExceptionRes(parsedOutput, context);
3036
- case "ResourceNotFoundException":
3037
- case "com.amazonaws.opensearch#ResourceNotFoundException":
3038
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3039
- default:
3040
- const parsedBody = parsedOutput.body;
3041
- return throwDefaultError({
3042
- output,
3043
- parsedBody,
3044
- errorCode,
3045
- });
3046
- }
3047
- };
3048
1564
  export const de_PurchaseReservedInstanceOfferingCommand = async (output, context) => {
3049
1565
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3050
- return de_PurchaseReservedInstanceOfferingCommandError(output, context);
1566
+ return de_CommandError(output, context);
3051
1567
  }
3052
1568
  const contents = map({
3053
1569
  $metadata: deserializeMetadata(output),
@@ -3060,43 +1576,9 @@ export const de_PurchaseReservedInstanceOfferingCommand = async (output, context
3060
1576
  Object.assign(contents, doc);
3061
1577
  return contents;
3062
1578
  };
3063
- const de_PurchaseReservedInstanceOfferingCommandError = async (output, context) => {
3064
- const parsedOutput = {
3065
- ...output,
3066
- body: await parseErrorBody(output.body, context),
3067
- };
3068
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3069
- switch (errorCode) {
3070
- case "DisabledOperationException":
3071
- case "com.amazonaws.opensearch#DisabledOperationException":
3072
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
3073
- case "InternalException":
3074
- case "com.amazonaws.opensearch#InternalException":
3075
- throw await de_InternalExceptionRes(parsedOutput, context);
3076
- case "LimitExceededException":
3077
- case "com.amazonaws.opensearch#LimitExceededException":
3078
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3079
- case "ResourceAlreadyExistsException":
3080
- case "com.amazonaws.opensearch#ResourceAlreadyExistsException":
3081
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
3082
- case "ResourceNotFoundException":
3083
- case "com.amazonaws.opensearch#ResourceNotFoundException":
3084
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3085
- case "ValidationException":
3086
- case "com.amazonaws.opensearch#ValidationException":
3087
- throw await de_ValidationExceptionRes(parsedOutput, context);
3088
- default:
3089
- const parsedBody = parsedOutput.body;
3090
- return throwDefaultError({
3091
- output,
3092
- parsedBody,
3093
- errorCode,
3094
- });
3095
- }
3096
- };
3097
1579
  export const de_RejectInboundConnectionCommand = async (output, context) => {
3098
1580
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3099
- return de_RejectInboundConnectionCommandError(output, context);
1581
+ return de_CommandError(output, context);
3100
1582
  }
3101
1583
  const contents = map({
3102
1584
  $metadata: deserializeMetadata(output),
@@ -3108,194 +1590,57 @@ export const de_RejectInboundConnectionCommand = async (output, context) => {
3108
1590
  Object.assign(contents, doc);
3109
1591
  return contents;
3110
1592
  };
3111
- const de_RejectInboundConnectionCommandError = async (output, context) => {
3112
- const parsedOutput = {
3113
- ...output,
3114
- body: await parseErrorBody(output.body, context),
3115
- };
3116
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3117
- switch (errorCode) {
3118
- case "DisabledOperationException":
3119
- case "com.amazonaws.opensearch#DisabledOperationException":
3120
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
3121
- case "ResourceNotFoundException":
3122
- case "com.amazonaws.opensearch#ResourceNotFoundException":
3123
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3124
- default:
3125
- const parsedBody = parsedOutput.body;
3126
- return throwDefaultError({
3127
- output,
3128
- parsedBody,
3129
- errorCode,
3130
- });
3131
- }
3132
- };
3133
1593
  export const de_RemoveTagsCommand = async (output, context) => {
3134
1594
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3135
- return de_RemoveTagsCommandError(output, context);
1595
+ return de_CommandError(output, context);
3136
1596
  }
3137
1597
  const contents = map({
3138
1598
  $metadata: deserializeMetadata(output),
3139
1599
  });
3140
1600
  await collectBody(output.body, context);
3141
- return contents;
3142
- };
3143
- const de_RemoveTagsCommandError = async (output, context) => {
3144
- const parsedOutput = {
3145
- ...output,
3146
- body: await parseErrorBody(output.body, context),
3147
- };
3148
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3149
- switch (errorCode) {
3150
- case "BaseException":
3151
- case "com.amazonaws.opensearch#BaseException":
3152
- throw await de_BaseExceptionRes(parsedOutput, context);
3153
- case "InternalException":
3154
- case "com.amazonaws.opensearch#InternalException":
3155
- throw await de_InternalExceptionRes(parsedOutput, context);
3156
- case "ValidationException":
3157
- case "com.amazonaws.opensearch#ValidationException":
3158
- throw await de_ValidationExceptionRes(parsedOutput, context);
3159
- default:
3160
- const parsedBody = parsedOutput.body;
3161
- return throwDefaultError({
3162
- output,
3163
- parsedBody,
3164
- errorCode,
3165
- });
3166
- }
3167
- };
3168
- export const de_RevokeVpcEndpointAccessCommand = async (output, context) => {
3169
- if (output.statusCode !== 200 && output.statusCode >= 300) {
3170
- return de_RevokeVpcEndpointAccessCommandError(output, context);
3171
- }
3172
- const contents = map({
3173
- $metadata: deserializeMetadata(output),
3174
- });
3175
- await collectBody(output.body, context);
3176
- return contents;
3177
- };
3178
- const de_RevokeVpcEndpointAccessCommandError = async (output, context) => {
3179
- const parsedOutput = {
3180
- ...output,
3181
- body: await parseErrorBody(output.body, context),
3182
- };
3183
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3184
- switch (errorCode) {
3185
- case "BaseException":
3186
- case "com.amazonaws.opensearch#BaseException":
3187
- throw await de_BaseExceptionRes(parsedOutput, context);
3188
- case "DisabledOperationException":
3189
- case "com.amazonaws.opensearch#DisabledOperationException":
3190
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
3191
- case "InternalException":
3192
- case "com.amazonaws.opensearch#InternalException":
3193
- throw await de_InternalExceptionRes(parsedOutput, context);
3194
- case "ResourceNotFoundException":
3195
- case "com.amazonaws.opensearch#ResourceNotFoundException":
3196
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3197
- case "ValidationException":
3198
- case "com.amazonaws.opensearch#ValidationException":
3199
- throw await de_ValidationExceptionRes(parsedOutput, context);
3200
- default:
3201
- const parsedBody = parsedOutput.body;
3202
- return throwDefaultError({
3203
- output,
3204
- parsedBody,
3205
- errorCode,
3206
- });
3207
- }
3208
- };
3209
- export const de_StartDomainMaintenanceCommand = async (output, context) => {
3210
- if (output.statusCode !== 200 && output.statusCode >= 300) {
3211
- return de_StartDomainMaintenanceCommandError(output, context);
3212
- }
3213
- const contents = map({
3214
- $metadata: deserializeMetadata(output),
3215
- });
3216
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3217
- const doc = take(data, {
3218
- MaintenanceId: __expectString,
3219
- });
3220
- Object.assign(contents, doc);
3221
- return contents;
3222
- };
3223
- const de_StartDomainMaintenanceCommandError = async (output, context) => {
3224
- const parsedOutput = {
3225
- ...output,
3226
- body: await parseErrorBody(output.body, context),
3227
- };
3228
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3229
- switch (errorCode) {
3230
- case "BaseException":
3231
- case "com.amazonaws.opensearch#BaseException":
3232
- throw await de_BaseExceptionRes(parsedOutput, context);
3233
- case "DisabledOperationException":
3234
- case "com.amazonaws.opensearch#DisabledOperationException":
3235
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
3236
- case "InternalException":
3237
- case "com.amazonaws.opensearch#InternalException":
3238
- throw await de_InternalExceptionRes(parsedOutput, context);
3239
- case "ResourceNotFoundException":
3240
- case "com.amazonaws.opensearch#ResourceNotFoundException":
3241
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3242
- case "ValidationException":
3243
- case "com.amazonaws.opensearch#ValidationException":
3244
- throw await de_ValidationExceptionRes(parsedOutput, context);
3245
- default:
3246
- const parsedBody = parsedOutput.body;
3247
- return throwDefaultError({
3248
- output,
3249
- parsedBody,
3250
- errorCode,
3251
- });
1601
+ return contents;
1602
+ };
1603
+ export const de_RevokeVpcEndpointAccessCommand = async (output, context) => {
1604
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1605
+ return de_CommandError(output, context);
3252
1606
  }
1607
+ const contents = map({
1608
+ $metadata: deserializeMetadata(output),
1609
+ });
1610
+ await collectBody(output.body, context);
1611
+ return contents;
3253
1612
  };
3254
- export const de_StartServiceSoftwareUpdateCommand = async (output, context) => {
1613
+ export const de_StartDomainMaintenanceCommand = async (output, context) => {
3255
1614
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3256
- return de_StartServiceSoftwareUpdateCommandError(output, context);
1615
+ return de_CommandError(output, context);
3257
1616
  }
3258
1617
  const contents = map({
3259
1618
  $metadata: deserializeMetadata(output),
3260
1619
  });
3261
1620
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3262
1621
  const doc = take(data, {
3263
- ServiceSoftwareOptions: (_) => de_ServiceSoftwareOptions(_, context),
1622
+ MaintenanceId: __expectString,
3264
1623
  });
3265
1624
  Object.assign(contents, doc);
3266
1625
  return contents;
3267
1626
  };
3268
- const de_StartServiceSoftwareUpdateCommandError = async (output, context) => {
3269
- const parsedOutput = {
3270
- ...output,
3271
- body: await parseErrorBody(output.body, context),
3272
- };
3273
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3274
- switch (errorCode) {
3275
- case "BaseException":
3276
- case "com.amazonaws.opensearch#BaseException":
3277
- throw await de_BaseExceptionRes(parsedOutput, context);
3278
- case "InternalException":
3279
- case "com.amazonaws.opensearch#InternalException":
3280
- throw await de_InternalExceptionRes(parsedOutput, context);
3281
- case "ResourceNotFoundException":
3282
- case "com.amazonaws.opensearch#ResourceNotFoundException":
3283
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3284
- case "ValidationException":
3285
- case "com.amazonaws.opensearch#ValidationException":
3286
- throw await de_ValidationExceptionRes(parsedOutput, context);
3287
- default:
3288
- const parsedBody = parsedOutput.body;
3289
- return throwDefaultError({
3290
- output,
3291
- parsedBody,
3292
- errorCode,
3293
- });
1627
+ export const de_StartServiceSoftwareUpdateCommand = async (output, context) => {
1628
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1629
+ return de_CommandError(output, context);
3294
1630
  }
1631
+ const contents = map({
1632
+ $metadata: deserializeMetadata(output),
1633
+ });
1634
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1635
+ const doc = take(data, {
1636
+ ServiceSoftwareOptions: (_) => de_ServiceSoftwareOptions(_, context),
1637
+ });
1638
+ Object.assign(contents, doc);
1639
+ return contents;
3295
1640
  };
3296
1641
  export const de_UpdateDataSourceCommand = async (output, context) => {
3297
1642
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3298
- return de_UpdateDataSourceCommandError(output, context);
1643
+ return de_CommandError(output, context);
3299
1644
  }
3300
1645
  const contents = map({
3301
1646
  $metadata: deserializeMetadata(output),
@@ -3307,43 +1652,9 @@ export const de_UpdateDataSourceCommand = async (output, context) => {
3307
1652
  Object.assign(contents, doc);
3308
1653
  return contents;
3309
1654
  };
3310
- const de_UpdateDataSourceCommandError = async (output, context) => {
3311
- const parsedOutput = {
3312
- ...output,
3313
- body: await parseErrorBody(output.body, context),
3314
- };
3315
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3316
- switch (errorCode) {
3317
- case "BaseException":
3318
- case "com.amazonaws.opensearch#BaseException":
3319
- throw await de_BaseExceptionRes(parsedOutput, context);
3320
- case "DependencyFailureException":
3321
- case "com.amazonaws.opensearch#DependencyFailureException":
3322
- throw await de_DependencyFailureExceptionRes(parsedOutput, context);
3323
- case "DisabledOperationException":
3324
- case "com.amazonaws.opensearch#DisabledOperationException":
3325
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
3326
- case "InternalException":
3327
- case "com.amazonaws.opensearch#InternalException":
3328
- throw await de_InternalExceptionRes(parsedOutput, context);
3329
- case "ResourceNotFoundException":
3330
- case "com.amazonaws.opensearch#ResourceNotFoundException":
3331
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3332
- case "ValidationException":
3333
- case "com.amazonaws.opensearch#ValidationException":
3334
- throw await de_ValidationExceptionRes(parsedOutput, context);
3335
- default:
3336
- const parsedBody = parsedOutput.body;
3337
- return throwDefaultError({
3338
- output,
3339
- parsedBody,
3340
- errorCode,
3341
- });
3342
- }
3343
- };
3344
1655
  export const de_UpdateDomainConfigCommand = async (output, context) => {
3345
1656
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3346
- return de_UpdateDomainConfigCommandError(output, context);
1657
+ return de_CommandError(output, context);
3347
1658
  }
3348
1659
  const contents = map({
3349
1660
  $metadata: deserializeMetadata(output),
@@ -3357,43 +1668,9 @@ export const de_UpdateDomainConfigCommand = async (output, context) => {
3357
1668
  Object.assign(contents, doc);
3358
1669
  return contents;
3359
1670
  };
3360
- const de_UpdateDomainConfigCommandError = async (output, context) => {
3361
- const parsedOutput = {
3362
- ...output,
3363
- body: await parseErrorBody(output.body, context),
3364
- };
3365
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3366
- switch (errorCode) {
3367
- case "BaseException":
3368
- case "com.amazonaws.opensearch#BaseException":
3369
- throw await de_BaseExceptionRes(parsedOutput, context);
3370
- case "InternalException":
3371
- case "com.amazonaws.opensearch#InternalException":
3372
- throw await de_InternalExceptionRes(parsedOutput, context);
3373
- case "InvalidTypeException":
3374
- case "com.amazonaws.opensearch#InvalidTypeException":
3375
- throw await de_InvalidTypeExceptionRes(parsedOutput, context);
3376
- case "LimitExceededException":
3377
- case "com.amazonaws.opensearch#LimitExceededException":
3378
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3379
- case "ResourceNotFoundException":
3380
- case "com.amazonaws.opensearch#ResourceNotFoundException":
3381
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3382
- case "ValidationException":
3383
- case "com.amazonaws.opensearch#ValidationException":
3384
- throw await de_ValidationExceptionRes(parsedOutput, context);
3385
- default:
3386
- const parsedBody = parsedOutput.body;
3387
- return throwDefaultError({
3388
- output,
3389
- parsedBody,
3390
- errorCode,
3391
- });
3392
- }
3393
- };
3394
1671
  export const de_UpdatePackageCommand = async (output, context) => {
3395
1672
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3396
- return de_UpdatePackageCommandError(output, context);
1673
+ return de_CommandError(output, context);
3397
1674
  }
3398
1675
  const contents = map({
3399
1676
  $metadata: deserializeMetadata(output),
@@ -3405,43 +1682,9 @@ export const de_UpdatePackageCommand = async (output, context) => {
3405
1682
  Object.assign(contents, doc);
3406
1683
  return contents;
3407
1684
  };
3408
- const de_UpdatePackageCommandError = async (output, context) => {
3409
- const parsedOutput = {
3410
- ...output,
3411
- body: await parseErrorBody(output.body, context),
3412
- };
3413
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3414
- switch (errorCode) {
3415
- case "AccessDeniedException":
3416
- case "com.amazonaws.opensearch#AccessDeniedException":
3417
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3418
- case "BaseException":
3419
- case "com.amazonaws.opensearch#BaseException":
3420
- throw await de_BaseExceptionRes(parsedOutput, context);
3421
- case "InternalException":
3422
- case "com.amazonaws.opensearch#InternalException":
3423
- throw await de_InternalExceptionRes(parsedOutput, context);
3424
- case "LimitExceededException":
3425
- case "com.amazonaws.opensearch#LimitExceededException":
3426
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3427
- case "ResourceNotFoundException":
3428
- case "com.amazonaws.opensearch#ResourceNotFoundException":
3429
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3430
- case "ValidationException":
3431
- case "com.amazonaws.opensearch#ValidationException":
3432
- throw await de_ValidationExceptionRes(parsedOutput, context);
3433
- default:
3434
- const parsedBody = parsedOutput.body;
3435
- return throwDefaultError({
3436
- output,
3437
- parsedBody,
3438
- errorCode,
3439
- });
3440
- }
3441
- };
3442
1685
  export const de_UpdateScheduledActionCommand = async (output, context) => {
3443
1686
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3444
- return de_UpdateScheduledActionCommandError(output, context);
1687
+ return de_CommandError(output, context);
3445
1688
  }
3446
1689
  const contents = map({
3447
1690
  $metadata: deserializeMetadata(output),
@@ -3453,46 +1696,9 @@ export const de_UpdateScheduledActionCommand = async (output, context) => {
3453
1696
  Object.assign(contents, doc);
3454
1697
  return contents;
3455
1698
  };
3456
- const de_UpdateScheduledActionCommandError = async (output, context) => {
3457
- const parsedOutput = {
3458
- ...output,
3459
- body: await parseErrorBody(output.body, context),
3460
- };
3461
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3462
- switch (errorCode) {
3463
- case "BaseException":
3464
- case "com.amazonaws.opensearch#BaseException":
3465
- throw await de_BaseExceptionRes(parsedOutput, context);
3466
- case "ConflictException":
3467
- case "com.amazonaws.opensearch#ConflictException":
3468
- throw await de_ConflictExceptionRes(parsedOutput, context);
3469
- case "InternalException":
3470
- case "com.amazonaws.opensearch#InternalException":
3471
- throw await de_InternalExceptionRes(parsedOutput, context);
3472
- case "LimitExceededException":
3473
- case "com.amazonaws.opensearch#LimitExceededException":
3474
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3475
- case "ResourceNotFoundException":
3476
- case "com.amazonaws.opensearch#ResourceNotFoundException":
3477
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3478
- case "SlotNotAvailableException":
3479
- case "com.amazonaws.opensearch#SlotNotAvailableException":
3480
- throw await de_SlotNotAvailableExceptionRes(parsedOutput, context);
3481
- case "ValidationException":
3482
- case "com.amazonaws.opensearch#ValidationException":
3483
- throw await de_ValidationExceptionRes(parsedOutput, context);
3484
- default:
3485
- const parsedBody = parsedOutput.body;
3486
- return throwDefaultError({
3487
- output,
3488
- parsedBody,
3489
- errorCode,
3490
- });
3491
- }
3492
- };
3493
1699
  export const de_UpdateVpcEndpointCommand = async (output, context) => {
3494
1700
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3495
- return de_UpdateVpcEndpointCommandError(output, context);
1701
+ return de_CommandError(output, context);
3496
1702
  }
3497
1703
  const contents = map({
3498
1704
  $metadata: deserializeMetadata(output),
@@ -3504,43 +1710,9 @@ export const de_UpdateVpcEndpointCommand = async (output, context) => {
3504
1710
  Object.assign(contents, doc);
3505
1711
  return contents;
3506
1712
  };
3507
- const de_UpdateVpcEndpointCommandError = async (output, context) => {
3508
- const parsedOutput = {
3509
- ...output,
3510
- body: await parseErrorBody(output.body, context),
3511
- };
3512
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3513
- switch (errorCode) {
3514
- case "BaseException":
3515
- case "com.amazonaws.opensearch#BaseException":
3516
- throw await de_BaseExceptionRes(parsedOutput, context);
3517
- case "ConflictException":
3518
- case "com.amazonaws.opensearch#ConflictException":
3519
- throw await de_ConflictExceptionRes(parsedOutput, context);
3520
- case "DisabledOperationException":
3521
- case "com.amazonaws.opensearch#DisabledOperationException":
3522
- throw await de_DisabledOperationExceptionRes(parsedOutput, context);
3523
- case "InternalException":
3524
- case "com.amazonaws.opensearch#InternalException":
3525
- throw await de_InternalExceptionRes(parsedOutput, context);
3526
- case "ResourceNotFoundException":
3527
- case "com.amazonaws.opensearch#ResourceNotFoundException":
3528
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3529
- case "ValidationException":
3530
- case "com.amazonaws.opensearch#ValidationException":
3531
- throw await de_ValidationExceptionRes(parsedOutput, context);
3532
- default:
3533
- const parsedBody = parsedOutput.body;
3534
- return throwDefaultError({
3535
- output,
3536
- parsedBody,
3537
- errorCode,
3538
- });
3539
- }
3540
- };
3541
1713
  export const de_UpgradeDomainCommand = async (output, context) => {
3542
1714
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3543
- return de_UpgradeDomainCommandError(output, context);
1715
+ return de_CommandError(output, context);
3544
1716
  }
3545
1717
  const contents = map({
3546
1718
  $metadata: deserializeMetadata(output),
@@ -3557,31 +1729,52 @@ export const de_UpgradeDomainCommand = async (output, context) => {
3557
1729
  Object.assign(contents, doc);
3558
1730
  return contents;
3559
1731
  };
3560
- const de_UpgradeDomainCommandError = async (output, context) => {
1732
+ const de_CommandError = async (output, context) => {
3561
1733
  const parsedOutput = {
3562
1734
  ...output,
3563
1735
  body: await parseErrorBody(output.body, context),
3564
1736
  };
3565
1737
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3566
1738
  switch (errorCode) {
3567
- case "BaseException":
3568
- case "com.amazonaws.opensearch#BaseException":
3569
- throw await de_BaseExceptionRes(parsedOutput, context);
3570
1739
  case "DisabledOperationException":
3571
1740
  case "com.amazonaws.opensearch#DisabledOperationException":
3572
1741
  throw await de_DisabledOperationExceptionRes(parsedOutput, context);
3573
- case "InternalException":
3574
- case "com.amazonaws.opensearch#InternalException":
3575
- throw await de_InternalExceptionRes(parsedOutput, context);
3576
- case "ResourceAlreadyExistsException":
3577
- case "com.amazonaws.opensearch#ResourceAlreadyExistsException":
3578
- throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
1742
+ case "LimitExceededException":
1743
+ case "com.amazonaws.opensearch#LimitExceededException":
1744
+ throw await de_LimitExceededExceptionRes(parsedOutput, context);
3579
1745
  case "ResourceNotFoundException":
3580
1746
  case "com.amazonaws.opensearch#ResourceNotFoundException":
3581
1747
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1748
+ case "BaseException":
1749
+ case "com.amazonaws.opensearch#BaseException":
1750
+ throw await de_BaseExceptionRes(parsedOutput, context);
1751
+ case "DependencyFailureException":
1752
+ case "com.amazonaws.opensearch#DependencyFailureException":
1753
+ throw await de_DependencyFailureExceptionRes(parsedOutput, context);
1754
+ case "InternalException":
1755
+ case "com.amazonaws.opensearch#InternalException":
1756
+ throw await de_InternalExceptionRes(parsedOutput, context);
3582
1757
  case "ValidationException":
3583
1758
  case "com.amazonaws.opensearch#ValidationException":
3584
1759
  throw await de_ValidationExceptionRes(parsedOutput, context);
1760
+ case "AccessDeniedException":
1761
+ case "com.amazonaws.opensearch#AccessDeniedException":
1762
+ throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1763
+ case "ConflictException":
1764
+ case "com.amazonaws.opensearch#ConflictException":
1765
+ throw await de_ConflictExceptionRes(parsedOutput, context);
1766
+ case "InvalidTypeException":
1767
+ case "com.amazonaws.opensearch#InvalidTypeException":
1768
+ throw await de_InvalidTypeExceptionRes(parsedOutput, context);
1769
+ case "ResourceAlreadyExistsException":
1770
+ case "com.amazonaws.opensearch#ResourceAlreadyExistsException":
1771
+ throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
1772
+ case "InvalidPaginationTokenException":
1773
+ case "com.amazonaws.opensearch#InvalidPaginationTokenException":
1774
+ throw await de_InvalidPaginationTokenExceptionRes(parsedOutput, context);
1775
+ case "SlotNotAvailableException":
1776
+ case "com.amazonaws.opensearch#SlotNotAvailableException":
1777
+ throw await de_SlotNotAvailableExceptionRes(parsedOutput, context);
3585
1778
  default:
3586
1779
  const parsedBody = parsedOutput.body;
3587
1780
  return throwDefaultError({