@aws-sdk/client-amplifybackend 3.504.0 → 3.509.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 +33 -873
  2. package/dist-es/protocols/Aws_restJson1.js +32 -872
  3. package/package.json +3 -3
package/dist-cjs/index.js CHANGED
@@ -974,7 +974,7 @@ var se_UpdateBackendStorageCommand = /* @__PURE__ */ __name(async (input, contex
974
974
  }, "se_UpdateBackendStorageCommand");
975
975
  var de_CloneBackendCommand = /* @__PURE__ */ __name(async (output, context) => {
976
976
  if (output.statusCode !== 200 && output.statusCode >= 300) {
977
- return de_CloneBackendCommandError(output, context);
977
+ return de_CommandError(output, context);
978
978
  }
979
979
  const contents = (0, import_smithy_client.map)({
980
980
  $metadata: deserializeMetadata(output)
@@ -991,37 +991,9 @@ var de_CloneBackendCommand = /* @__PURE__ */ __name(async (output, context) => {
991
991
  Object.assign(contents, doc);
992
992
  return contents;
993
993
  }, "de_CloneBackendCommand");
994
- var de_CloneBackendCommandError = /* @__PURE__ */ __name(async (output, context) => {
995
- const parsedOutput = {
996
- ...output,
997
- body: await parseErrorBody(output.body, context)
998
- };
999
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1000
- switch (errorCode) {
1001
- case "BadRequestException":
1002
- case "com.amazonaws.amplifybackend#BadRequestException":
1003
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1004
- case "GatewayTimeoutException":
1005
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1006
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1007
- case "NotFoundException":
1008
- case "com.amazonaws.amplifybackend#NotFoundException":
1009
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1010
- case "TooManyRequestsException":
1011
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1012
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1013
- default:
1014
- const parsedBody = parsedOutput.body;
1015
- return throwDefaultError({
1016
- output,
1017
- parsedBody,
1018
- errorCode
1019
- });
1020
- }
1021
- }, "de_CloneBackendCommandError");
1022
994
  var de_CreateBackendCommand = /* @__PURE__ */ __name(async (output, context) => {
1023
995
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1024
- return de_CreateBackendCommandError(output, context);
996
+ return de_CommandError(output, context);
1025
997
  }
1026
998
  const contents = (0, import_smithy_client.map)({
1027
999
  $metadata: deserializeMetadata(output)
@@ -1038,37 +1010,9 @@ var de_CreateBackendCommand = /* @__PURE__ */ __name(async (output, context) =>
1038
1010
  Object.assign(contents, doc);
1039
1011
  return contents;
1040
1012
  }, "de_CreateBackendCommand");
1041
- var de_CreateBackendCommandError = /* @__PURE__ */ __name(async (output, context) => {
1042
- const parsedOutput = {
1043
- ...output,
1044
- body: await parseErrorBody(output.body, context)
1045
- };
1046
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1047
- switch (errorCode) {
1048
- case "BadRequestException":
1049
- case "com.amazonaws.amplifybackend#BadRequestException":
1050
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1051
- case "GatewayTimeoutException":
1052
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1053
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1054
- case "NotFoundException":
1055
- case "com.amazonaws.amplifybackend#NotFoundException":
1056
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1057
- case "TooManyRequestsException":
1058
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1059
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1060
- default:
1061
- const parsedBody = parsedOutput.body;
1062
- return throwDefaultError({
1063
- output,
1064
- parsedBody,
1065
- errorCode
1066
- });
1067
- }
1068
- }, "de_CreateBackendCommandError");
1069
1013
  var de_CreateBackendAPICommand = /* @__PURE__ */ __name(async (output, context) => {
1070
1014
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1071
- return de_CreateBackendAPICommandError(output, context);
1015
+ return de_CommandError(output, context);
1072
1016
  }
1073
1017
  const contents = (0, import_smithy_client.map)({
1074
1018
  $metadata: deserializeMetadata(output)
@@ -1085,37 +1029,9 @@ var de_CreateBackendAPICommand = /* @__PURE__ */ __name(async (output, context)
1085
1029
  Object.assign(contents, doc);
1086
1030
  return contents;
1087
1031
  }, "de_CreateBackendAPICommand");
1088
- var de_CreateBackendAPICommandError = /* @__PURE__ */ __name(async (output, context) => {
1089
- const parsedOutput = {
1090
- ...output,
1091
- body: await parseErrorBody(output.body, context)
1092
- };
1093
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1094
- switch (errorCode) {
1095
- case "BadRequestException":
1096
- case "com.amazonaws.amplifybackend#BadRequestException":
1097
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1098
- case "GatewayTimeoutException":
1099
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1100
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1101
- case "NotFoundException":
1102
- case "com.amazonaws.amplifybackend#NotFoundException":
1103
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1104
- case "TooManyRequestsException":
1105
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1106
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1107
- default:
1108
- const parsedBody = parsedOutput.body;
1109
- return throwDefaultError({
1110
- output,
1111
- parsedBody,
1112
- errorCode
1113
- });
1114
- }
1115
- }, "de_CreateBackendAPICommandError");
1116
1032
  var de_CreateBackendAuthCommand = /* @__PURE__ */ __name(async (output, context) => {
1117
1033
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1118
- return de_CreateBackendAuthCommandError(output, context);
1034
+ return de_CommandError(output, context);
1119
1035
  }
1120
1036
  const contents = (0, import_smithy_client.map)({
1121
1037
  $metadata: deserializeMetadata(output)
@@ -1132,37 +1048,9 @@ var de_CreateBackendAuthCommand = /* @__PURE__ */ __name(async (output, context)
1132
1048
  Object.assign(contents, doc);
1133
1049
  return contents;
1134
1050
  }, "de_CreateBackendAuthCommand");
1135
- var de_CreateBackendAuthCommandError = /* @__PURE__ */ __name(async (output, context) => {
1136
- const parsedOutput = {
1137
- ...output,
1138
- body: await parseErrorBody(output.body, context)
1139
- };
1140
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1141
- switch (errorCode) {
1142
- case "BadRequestException":
1143
- case "com.amazonaws.amplifybackend#BadRequestException":
1144
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1145
- case "GatewayTimeoutException":
1146
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1147
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1148
- case "NotFoundException":
1149
- case "com.amazonaws.amplifybackend#NotFoundException":
1150
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1151
- case "TooManyRequestsException":
1152
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1153
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1154
- default:
1155
- const parsedBody = parsedOutput.body;
1156
- return throwDefaultError({
1157
- output,
1158
- parsedBody,
1159
- errorCode
1160
- });
1161
- }
1162
- }, "de_CreateBackendAuthCommandError");
1163
1051
  var de_CreateBackendConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
1164
1052
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1165
- return de_CreateBackendConfigCommandError(output, context);
1053
+ return de_CommandError(output, context);
1166
1054
  }
1167
1055
  const contents = (0, import_smithy_client.map)({
1168
1056
  $metadata: deserializeMetadata(output)
@@ -1177,37 +1065,9 @@ var de_CreateBackendConfigCommand = /* @__PURE__ */ __name(async (output, contex
1177
1065
  Object.assign(contents, doc);
1178
1066
  return contents;
1179
1067
  }, "de_CreateBackendConfigCommand");
1180
- var de_CreateBackendConfigCommandError = /* @__PURE__ */ __name(async (output, context) => {
1181
- const parsedOutput = {
1182
- ...output,
1183
- body: await parseErrorBody(output.body, context)
1184
- };
1185
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1186
- switch (errorCode) {
1187
- case "BadRequestException":
1188
- case "com.amazonaws.amplifybackend#BadRequestException":
1189
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1190
- case "GatewayTimeoutException":
1191
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1192
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1193
- case "NotFoundException":
1194
- case "com.amazonaws.amplifybackend#NotFoundException":
1195
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1196
- case "TooManyRequestsException":
1197
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1198
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1199
- default:
1200
- const parsedBody = parsedOutput.body;
1201
- return throwDefaultError({
1202
- output,
1203
- parsedBody,
1204
- errorCode
1205
- });
1206
- }
1207
- }, "de_CreateBackendConfigCommandError");
1208
1068
  var de_CreateBackendStorageCommand = /* @__PURE__ */ __name(async (output, context) => {
1209
1069
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1210
- return de_CreateBackendStorageCommandError(output, context);
1070
+ return de_CommandError(output, context);
1211
1071
  }
1212
1072
  const contents = (0, import_smithy_client.map)({
1213
1073
  $metadata: deserializeMetadata(output)
@@ -1222,37 +1082,9 @@ var de_CreateBackendStorageCommand = /* @__PURE__ */ __name(async (output, conte
1222
1082
  Object.assign(contents, doc);
1223
1083
  return contents;
1224
1084
  }, "de_CreateBackendStorageCommand");
1225
- var de_CreateBackendStorageCommandError = /* @__PURE__ */ __name(async (output, context) => {
1226
- const parsedOutput = {
1227
- ...output,
1228
- body: await parseErrorBody(output.body, context)
1229
- };
1230
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1231
- switch (errorCode) {
1232
- case "BadRequestException":
1233
- case "com.amazonaws.amplifybackend#BadRequestException":
1234
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1235
- case "GatewayTimeoutException":
1236
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1237
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1238
- case "NotFoundException":
1239
- case "com.amazonaws.amplifybackend#NotFoundException":
1240
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1241
- case "TooManyRequestsException":
1242
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1243
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1244
- default:
1245
- const parsedBody = parsedOutput.body;
1246
- return throwDefaultError({
1247
- output,
1248
- parsedBody,
1249
- errorCode
1250
- });
1251
- }
1252
- }, "de_CreateBackendStorageCommandError");
1253
1085
  var de_CreateTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
1254
1086
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1255
- return de_CreateTokenCommandError(output, context);
1087
+ return de_CommandError(output, context);
1256
1088
  }
1257
1089
  const contents = (0, import_smithy_client.map)({
1258
1090
  $metadata: deserializeMetadata(output)
@@ -1267,37 +1099,9 @@ var de_CreateTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
1267
1099
  Object.assign(contents, doc);
1268
1100
  return contents;
1269
1101
  }, "de_CreateTokenCommand");
1270
- var de_CreateTokenCommandError = /* @__PURE__ */ __name(async (output, context) => {
1271
- const parsedOutput = {
1272
- ...output,
1273
- body: await parseErrorBody(output.body, context)
1274
- };
1275
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1276
- switch (errorCode) {
1277
- case "BadRequestException":
1278
- case "com.amazonaws.amplifybackend#BadRequestException":
1279
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1280
- case "GatewayTimeoutException":
1281
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1282
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1283
- case "NotFoundException":
1284
- case "com.amazonaws.amplifybackend#NotFoundException":
1285
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1286
- case "TooManyRequestsException":
1287
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1288
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1289
- default:
1290
- const parsedBody = parsedOutput.body;
1291
- return throwDefaultError({
1292
- output,
1293
- parsedBody,
1294
- errorCode
1295
- });
1296
- }
1297
- }, "de_CreateTokenCommandError");
1298
1102
  var de_DeleteBackendCommand = /* @__PURE__ */ __name(async (output, context) => {
1299
1103
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1300
- return de_DeleteBackendCommandError(output, context);
1104
+ return de_CommandError(output, context);
1301
1105
  }
1302
1106
  const contents = (0, import_smithy_client.map)({
1303
1107
  $metadata: deserializeMetadata(output)
@@ -1314,37 +1118,9 @@ var de_DeleteBackendCommand = /* @__PURE__ */ __name(async (output, context) =>
1314
1118
  Object.assign(contents, doc);
1315
1119
  return contents;
1316
1120
  }, "de_DeleteBackendCommand");
1317
- var de_DeleteBackendCommandError = /* @__PURE__ */ __name(async (output, context) => {
1318
- const parsedOutput = {
1319
- ...output,
1320
- body: await parseErrorBody(output.body, context)
1321
- };
1322
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1323
- switch (errorCode) {
1324
- case "BadRequestException":
1325
- case "com.amazonaws.amplifybackend#BadRequestException":
1326
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1327
- case "GatewayTimeoutException":
1328
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1329
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1330
- case "NotFoundException":
1331
- case "com.amazonaws.amplifybackend#NotFoundException":
1332
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1333
- case "TooManyRequestsException":
1334
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1335
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1336
- default:
1337
- const parsedBody = parsedOutput.body;
1338
- return throwDefaultError({
1339
- output,
1340
- parsedBody,
1341
- errorCode
1342
- });
1343
- }
1344
- }, "de_DeleteBackendCommandError");
1345
1121
  var de_DeleteBackendAPICommand = /* @__PURE__ */ __name(async (output, context) => {
1346
1122
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1347
- return de_DeleteBackendAPICommandError(output, context);
1123
+ return de_CommandError(output, context);
1348
1124
  }
1349
1125
  const contents = (0, import_smithy_client.map)({
1350
1126
  $metadata: deserializeMetadata(output)
@@ -1361,37 +1137,9 @@ var de_DeleteBackendAPICommand = /* @__PURE__ */ __name(async (output, context)
1361
1137
  Object.assign(contents, doc);
1362
1138
  return contents;
1363
1139
  }, "de_DeleteBackendAPICommand");
1364
- var de_DeleteBackendAPICommandError = /* @__PURE__ */ __name(async (output, context) => {
1365
- const parsedOutput = {
1366
- ...output,
1367
- body: await parseErrorBody(output.body, context)
1368
- };
1369
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1370
- switch (errorCode) {
1371
- case "BadRequestException":
1372
- case "com.amazonaws.amplifybackend#BadRequestException":
1373
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1374
- case "GatewayTimeoutException":
1375
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1376
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1377
- case "NotFoundException":
1378
- case "com.amazonaws.amplifybackend#NotFoundException":
1379
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1380
- case "TooManyRequestsException":
1381
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1382
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1383
- default:
1384
- const parsedBody = parsedOutput.body;
1385
- return throwDefaultError({
1386
- output,
1387
- parsedBody,
1388
- errorCode
1389
- });
1390
- }
1391
- }, "de_DeleteBackendAPICommandError");
1392
1140
  var de_DeleteBackendAuthCommand = /* @__PURE__ */ __name(async (output, context) => {
1393
1141
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1394
- return de_DeleteBackendAuthCommandError(output, context);
1142
+ return de_CommandError(output, context);
1395
1143
  }
1396
1144
  const contents = (0, import_smithy_client.map)({
1397
1145
  $metadata: deserializeMetadata(output)
@@ -1408,37 +1156,9 @@ var de_DeleteBackendAuthCommand = /* @__PURE__ */ __name(async (output, context)
1408
1156
  Object.assign(contents, doc);
1409
1157
  return contents;
1410
1158
  }, "de_DeleteBackendAuthCommand");
1411
- var de_DeleteBackendAuthCommandError = /* @__PURE__ */ __name(async (output, context) => {
1412
- const parsedOutput = {
1413
- ...output,
1414
- body: await parseErrorBody(output.body, context)
1415
- };
1416
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1417
- switch (errorCode) {
1418
- case "BadRequestException":
1419
- case "com.amazonaws.amplifybackend#BadRequestException":
1420
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1421
- case "GatewayTimeoutException":
1422
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1423
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1424
- case "NotFoundException":
1425
- case "com.amazonaws.amplifybackend#NotFoundException":
1426
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1427
- case "TooManyRequestsException":
1428
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1429
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1430
- default:
1431
- const parsedBody = parsedOutput.body;
1432
- return throwDefaultError({
1433
- output,
1434
- parsedBody,
1435
- errorCode
1436
- });
1437
- }
1438
- }, "de_DeleteBackendAuthCommandError");
1439
1159
  var de_DeleteBackendStorageCommand = /* @__PURE__ */ __name(async (output, context) => {
1440
1160
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1441
- return de_DeleteBackendStorageCommandError(output, context);
1161
+ return de_CommandError(output, context);
1442
1162
  }
1443
1163
  const contents = (0, import_smithy_client.map)({
1444
1164
  $metadata: deserializeMetadata(output)
@@ -1453,37 +1173,9 @@ var de_DeleteBackendStorageCommand = /* @__PURE__ */ __name(async (output, conte
1453
1173
  Object.assign(contents, doc);
1454
1174
  return contents;
1455
1175
  }, "de_DeleteBackendStorageCommand");
1456
- var de_DeleteBackendStorageCommandError = /* @__PURE__ */ __name(async (output, context) => {
1457
- const parsedOutput = {
1458
- ...output,
1459
- body: await parseErrorBody(output.body, context)
1460
- };
1461
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1462
- switch (errorCode) {
1463
- case "BadRequestException":
1464
- case "com.amazonaws.amplifybackend#BadRequestException":
1465
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1466
- case "GatewayTimeoutException":
1467
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1468
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1469
- case "NotFoundException":
1470
- case "com.amazonaws.amplifybackend#NotFoundException":
1471
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1472
- case "TooManyRequestsException":
1473
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1474
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1475
- default:
1476
- const parsedBody = parsedOutput.body;
1477
- return throwDefaultError({
1478
- output,
1479
- parsedBody,
1480
- errorCode
1481
- });
1482
- }
1483
- }, "de_DeleteBackendStorageCommandError");
1484
1176
  var de_DeleteTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
1485
1177
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1486
- return de_DeleteTokenCommandError(output, context);
1178
+ return de_CommandError(output, context);
1487
1179
  }
1488
1180
  const contents = (0, import_smithy_client.map)({
1489
1181
  $metadata: deserializeMetadata(output)
@@ -1495,37 +1187,9 @@ var de_DeleteTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
1495
1187
  Object.assign(contents, doc);
1496
1188
  return contents;
1497
1189
  }, "de_DeleteTokenCommand");
1498
- var de_DeleteTokenCommandError = /* @__PURE__ */ __name(async (output, context) => {
1499
- const parsedOutput = {
1500
- ...output,
1501
- body: await parseErrorBody(output.body, context)
1502
- };
1503
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1504
- switch (errorCode) {
1505
- case "BadRequestException":
1506
- case "com.amazonaws.amplifybackend#BadRequestException":
1507
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1508
- case "GatewayTimeoutException":
1509
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1510
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1511
- case "NotFoundException":
1512
- case "com.amazonaws.amplifybackend#NotFoundException":
1513
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1514
- case "TooManyRequestsException":
1515
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1516
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1517
- default:
1518
- const parsedBody = parsedOutput.body;
1519
- return throwDefaultError({
1520
- output,
1521
- parsedBody,
1522
- errorCode
1523
- });
1524
- }
1525
- }, "de_DeleteTokenCommandError");
1526
1190
  var de_GenerateBackendAPIModelsCommand = /* @__PURE__ */ __name(async (output, context) => {
1527
1191
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1528
- return de_GenerateBackendAPIModelsCommandError(output, context);
1192
+ return de_CommandError(output, context);
1529
1193
  }
1530
1194
  const contents = (0, import_smithy_client.map)({
1531
1195
  $metadata: deserializeMetadata(output)
@@ -1542,37 +1206,9 @@ var de_GenerateBackendAPIModelsCommand = /* @__PURE__ */ __name(async (output, c
1542
1206
  Object.assign(contents, doc);
1543
1207
  return contents;
1544
1208
  }, "de_GenerateBackendAPIModelsCommand");
1545
- var de_GenerateBackendAPIModelsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1546
- const parsedOutput = {
1547
- ...output,
1548
- body: await parseErrorBody(output.body, context)
1549
- };
1550
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1551
- switch (errorCode) {
1552
- case "BadRequestException":
1553
- case "com.amazonaws.amplifybackend#BadRequestException":
1554
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1555
- case "GatewayTimeoutException":
1556
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1557
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1558
- case "NotFoundException":
1559
- case "com.amazonaws.amplifybackend#NotFoundException":
1560
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1561
- case "TooManyRequestsException":
1562
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1563
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1564
- default:
1565
- const parsedBody = parsedOutput.body;
1566
- return throwDefaultError({
1567
- output,
1568
- parsedBody,
1569
- errorCode
1570
- });
1571
- }
1572
- }, "de_GenerateBackendAPIModelsCommandError");
1573
1209
  var de_GetBackendCommand = /* @__PURE__ */ __name(async (output, context) => {
1574
1210
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1575
- return de_GetBackendCommandError(output, context);
1211
+ return de_CommandError(output, context);
1576
1212
  }
1577
1213
  const contents = (0, import_smithy_client.map)({
1578
1214
  $metadata: deserializeMetadata(output)
@@ -1590,37 +1226,9 @@ var de_GetBackendCommand = /* @__PURE__ */ __name(async (output, context) => {
1590
1226
  Object.assign(contents, doc);
1591
1227
  return contents;
1592
1228
  }, "de_GetBackendCommand");
1593
- var de_GetBackendCommandError = /* @__PURE__ */ __name(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 "BadRequestException":
1601
- case "com.amazonaws.amplifybackend#BadRequestException":
1602
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1603
- case "GatewayTimeoutException":
1604
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1605
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1606
- case "NotFoundException":
1607
- case "com.amazonaws.amplifybackend#NotFoundException":
1608
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1609
- case "TooManyRequestsException":
1610
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1611
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1612
- default:
1613
- const parsedBody = parsedOutput.body;
1614
- return throwDefaultError({
1615
- output,
1616
- parsedBody,
1617
- errorCode
1618
- });
1619
- }
1620
- }, "de_GetBackendCommandError");
1621
1229
  var de_GetBackendAPICommand = /* @__PURE__ */ __name(async (output, context) => {
1622
1230
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1623
- return de_GetBackendAPICommandError(output, context);
1231
+ return de_CommandError(output, context);
1624
1232
  }
1625
1233
  const contents = (0, import_smithy_client.map)({
1626
1234
  $metadata: deserializeMetadata(output)
@@ -1636,37 +1244,9 @@ var de_GetBackendAPICommand = /* @__PURE__ */ __name(async (output, context) =>
1636
1244
  Object.assign(contents, doc);
1637
1245
  return contents;
1638
1246
  }, "de_GetBackendAPICommand");
1639
- var de_GetBackendAPICommandError = /* @__PURE__ */ __name(async (output, context) => {
1640
- const parsedOutput = {
1641
- ...output,
1642
- body: await parseErrorBody(output.body, context)
1643
- };
1644
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1645
- switch (errorCode) {
1646
- case "BadRequestException":
1647
- case "com.amazonaws.amplifybackend#BadRequestException":
1648
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1649
- case "GatewayTimeoutException":
1650
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1651
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1652
- case "NotFoundException":
1653
- case "com.amazonaws.amplifybackend#NotFoundException":
1654
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1655
- case "TooManyRequestsException":
1656
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1657
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1658
- default:
1659
- const parsedBody = parsedOutput.body;
1660
- return throwDefaultError({
1661
- output,
1662
- parsedBody,
1663
- errorCode
1664
- });
1665
- }
1666
- }, "de_GetBackendAPICommandError");
1667
1247
  var de_GetBackendAPIModelsCommand = /* @__PURE__ */ __name(async (output, context) => {
1668
1248
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1669
- return de_GetBackendAPIModelsCommandError(output, context);
1249
+ return de_CommandError(output, context);
1670
1250
  }
1671
1251
  const contents = (0, import_smithy_client.map)({
1672
1252
  $metadata: deserializeMetadata(output)
@@ -1680,37 +1260,9 @@ var de_GetBackendAPIModelsCommand = /* @__PURE__ */ __name(async (output, contex
1680
1260
  Object.assign(contents, doc);
1681
1261
  return contents;
1682
1262
  }, "de_GetBackendAPIModelsCommand");
1683
- var de_GetBackendAPIModelsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1684
- const parsedOutput = {
1685
- ...output,
1686
- body: await parseErrorBody(output.body, context)
1687
- };
1688
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1689
- switch (errorCode) {
1690
- case "BadRequestException":
1691
- case "com.amazonaws.amplifybackend#BadRequestException":
1692
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1693
- case "GatewayTimeoutException":
1694
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1695
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1696
- case "NotFoundException":
1697
- case "com.amazonaws.amplifybackend#NotFoundException":
1698
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1699
- case "TooManyRequestsException":
1700
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1701
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1702
- default:
1703
- const parsedBody = parsedOutput.body;
1704
- return throwDefaultError({
1705
- output,
1706
- parsedBody,
1707
- errorCode
1708
- });
1709
- }
1710
- }, "de_GetBackendAPIModelsCommandError");
1711
1263
  var de_GetBackendAuthCommand = /* @__PURE__ */ __name(async (output, context) => {
1712
1264
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1713
- return de_GetBackendAuthCommandError(output, context);
1265
+ return de_CommandError(output, context);
1714
1266
  }
1715
1267
  const contents = (0, import_smithy_client.map)({
1716
1268
  $metadata: deserializeMetadata(output)
@@ -1726,37 +1278,9 @@ var de_GetBackendAuthCommand = /* @__PURE__ */ __name(async (output, context) =>
1726
1278
  Object.assign(contents, doc);
1727
1279
  return contents;
1728
1280
  }, "de_GetBackendAuthCommand");
1729
- var de_GetBackendAuthCommandError = /* @__PURE__ */ __name(async (output, context) => {
1730
- const parsedOutput = {
1731
- ...output,
1732
- body: await parseErrorBody(output.body, context)
1733
- };
1734
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1735
- switch (errorCode) {
1736
- case "BadRequestException":
1737
- case "com.amazonaws.amplifybackend#BadRequestException":
1738
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1739
- case "GatewayTimeoutException":
1740
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1741
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1742
- case "NotFoundException":
1743
- case "com.amazonaws.amplifybackend#NotFoundException":
1744
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1745
- case "TooManyRequestsException":
1746
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1747
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1748
- default:
1749
- const parsedBody = parsedOutput.body;
1750
- return throwDefaultError({
1751
- output,
1752
- parsedBody,
1753
- errorCode
1754
- });
1755
- }
1756
- }, "de_GetBackendAuthCommandError");
1757
1281
  var de_GetBackendJobCommand = /* @__PURE__ */ __name(async (output, context) => {
1758
1282
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1759
- return de_GetBackendJobCommandError(output, context);
1283
+ return de_CommandError(output, context);
1760
1284
  }
1761
1285
  const contents = (0, import_smithy_client.map)({
1762
1286
  $metadata: deserializeMetadata(output)
@@ -1775,37 +1299,9 @@ var de_GetBackendJobCommand = /* @__PURE__ */ __name(async (output, context) =>
1775
1299
  Object.assign(contents, doc);
1776
1300
  return contents;
1777
1301
  }, "de_GetBackendJobCommand");
1778
- var de_GetBackendJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
1779
- const parsedOutput = {
1780
- ...output,
1781
- body: await parseErrorBody(output.body, context)
1782
- };
1783
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1784
- switch (errorCode) {
1785
- case "BadRequestException":
1786
- case "com.amazonaws.amplifybackend#BadRequestException":
1787
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1788
- case "GatewayTimeoutException":
1789
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1790
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1791
- case "NotFoundException":
1792
- case "com.amazonaws.amplifybackend#NotFoundException":
1793
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1794
- case "TooManyRequestsException":
1795
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1796
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1797
- default:
1798
- const parsedBody = parsedOutput.body;
1799
- return throwDefaultError({
1800
- output,
1801
- parsedBody,
1802
- errorCode
1803
- });
1804
- }
1805
- }, "de_GetBackendJobCommandError");
1806
1302
  var de_GetBackendStorageCommand = /* @__PURE__ */ __name(async (output, context) => {
1807
1303
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1808
- return de_GetBackendStorageCommandError(output, context);
1304
+ return de_CommandError(output, context);
1809
1305
  }
1810
1306
  const contents = (0, import_smithy_client.map)({
1811
1307
  $metadata: deserializeMetadata(output)
@@ -1820,37 +1316,9 @@ var de_GetBackendStorageCommand = /* @__PURE__ */ __name(async (output, context)
1820
1316
  Object.assign(contents, doc);
1821
1317
  return contents;
1822
1318
  }, "de_GetBackendStorageCommand");
1823
- var de_GetBackendStorageCommandError = /* @__PURE__ */ __name(async (output, context) => {
1824
- const parsedOutput = {
1825
- ...output,
1826
- body: await parseErrorBody(output.body, context)
1827
- };
1828
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1829
- switch (errorCode) {
1830
- case "BadRequestException":
1831
- case "com.amazonaws.amplifybackend#BadRequestException":
1832
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1833
- case "GatewayTimeoutException":
1834
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1835
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1836
- case "NotFoundException":
1837
- case "com.amazonaws.amplifybackend#NotFoundException":
1838
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1839
- case "TooManyRequestsException":
1840
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1841
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1842
- default:
1843
- const parsedBody = parsedOutput.body;
1844
- return throwDefaultError({
1845
- output,
1846
- parsedBody,
1847
- errorCode
1848
- });
1849
- }
1850
- }, "de_GetBackendStorageCommandError");
1851
1319
  var de_GetTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
1852
1320
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1853
- return de_GetTokenCommandError(output, context);
1321
+ return de_CommandError(output, context);
1854
1322
  }
1855
1323
  const contents = (0, import_smithy_client.map)({
1856
1324
  $metadata: deserializeMetadata(output)
@@ -1865,37 +1333,9 @@ var de_GetTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
1865
1333
  Object.assign(contents, doc);
1866
1334
  return contents;
1867
1335
  }, "de_GetTokenCommand");
1868
- var de_GetTokenCommandError = /* @__PURE__ */ __name(async (output, context) => {
1869
- const parsedOutput = {
1870
- ...output,
1871
- body: await parseErrorBody(output.body, context)
1872
- };
1873
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1874
- switch (errorCode) {
1875
- case "BadRequestException":
1876
- case "com.amazonaws.amplifybackend#BadRequestException":
1877
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1878
- case "GatewayTimeoutException":
1879
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1880
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1881
- case "NotFoundException":
1882
- case "com.amazonaws.amplifybackend#NotFoundException":
1883
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1884
- case "TooManyRequestsException":
1885
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1886
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1887
- default:
1888
- const parsedBody = parsedOutput.body;
1889
- return throwDefaultError({
1890
- output,
1891
- parsedBody,
1892
- errorCode
1893
- });
1894
- }
1895
- }, "de_GetTokenCommandError");
1896
1336
  var de_ImportBackendAuthCommand = /* @__PURE__ */ __name(async (output, context) => {
1897
1337
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1898
- return de_ImportBackendAuthCommandError(output, context);
1338
+ return de_CommandError(output, context);
1899
1339
  }
1900
1340
  const contents = (0, import_smithy_client.map)({
1901
1341
  $metadata: deserializeMetadata(output)
@@ -1912,37 +1352,9 @@ var de_ImportBackendAuthCommand = /* @__PURE__ */ __name(async (output, context)
1912
1352
  Object.assign(contents, doc);
1913
1353
  return contents;
1914
1354
  }, "de_ImportBackendAuthCommand");
1915
- var de_ImportBackendAuthCommandError = /* @__PURE__ */ __name(async (output, context) => {
1916
- const parsedOutput = {
1917
- ...output,
1918
- body: await parseErrorBody(output.body, context)
1919
- };
1920
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1921
- switch (errorCode) {
1922
- case "BadRequestException":
1923
- case "com.amazonaws.amplifybackend#BadRequestException":
1924
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1925
- case "GatewayTimeoutException":
1926
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1927
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1928
- case "NotFoundException":
1929
- case "com.amazonaws.amplifybackend#NotFoundException":
1930
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1931
- case "TooManyRequestsException":
1932
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1933
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1934
- default:
1935
- const parsedBody = parsedOutput.body;
1936
- return throwDefaultError({
1937
- output,
1938
- parsedBody,
1939
- errorCode
1940
- });
1941
- }
1942
- }, "de_ImportBackendAuthCommandError");
1943
1355
  var de_ImportBackendStorageCommand = /* @__PURE__ */ __name(async (output, context) => {
1944
1356
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1945
- return de_ImportBackendStorageCommandError(output, context);
1357
+ return de_CommandError(output, context);
1946
1358
  }
1947
1359
  const contents = (0, import_smithy_client.map)({
1948
1360
  $metadata: deserializeMetadata(output)
@@ -1957,37 +1369,9 @@ var de_ImportBackendStorageCommand = /* @__PURE__ */ __name(async (output, conte
1957
1369
  Object.assign(contents, doc);
1958
1370
  return contents;
1959
1371
  }, "de_ImportBackendStorageCommand");
1960
- var de_ImportBackendStorageCommandError = /* @__PURE__ */ __name(async (output, context) => {
1961
- const parsedOutput = {
1962
- ...output,
1963
- body: await parseErrorBody(output.body, context)
1964
- };
1965
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1966
- switch (errorCode) {
1967
- case "BadRequestException":
1968
- case "com.amazonaws.amplifybackend#BadRequestException":
1969
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1970
- case "GatewayTimeoutException":
1971
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
1972
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
1973
- case "NotFoundException":
1974
- case "com.amazonaws.amplifybackend#NotFoundException":
1975
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1976
- case "TooManyRequestsException":
1977
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
1978
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1979
- default:
1980
- const parsedBody = parsedOutput.body;
1981
- return throwDefaultError({
1982
- output,
1983
- parsedBody,
1984
- errorCode
1985
- });
1986
- }
1987
- }, "de_ImportBackendStorageCommandError");
1988
1372
  var de_ListBackendJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
1989
1373
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1990
- return de_ListBackendJobsCommandError(output, context);
1374
+ return de_CommandError(output, context);
1991
1375
  }
1992
1376
  const contents = (0, import_smithy_client.map)({
1993
1377
  $metadata: deserializeMetadata(output)
@@ -2000,37 +1384,9 @@ var de_ListBackendJobsCommand = /* @__PURE__ */ __name(async (output, context) =
2000
1384
  Object.assign(contents, doc);
2001
1385
  return contents;
2002
1386
  }, "de_ListBackendJobsCommand");
2003
- var de_ListBackendJobsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2004
- const parsedOutput = {
2005
- ...output,
2006
- body: await parseErrorBody(output.body, context)
2007
- };
2008
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2009
- switch (errorCode) {
2010
- case "BadRequestException":
2011
- case "com.amazonaws.amplifybackend#BadRequestException":
2012
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2013
- case "GatewayTimeoutException":
2014
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
2015
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
2016
- case "NotFoundException":
2017
- case "com.amazonaws.amplifybackend#NotFoundException":
2018
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2019
- case "TooManyRequestsException":
2020
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
2021
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2022
- default:
2023
- const parsedBody = parsedOutput.body;
2024
- return throwDefaultError({
2025
- output,
2026
- parsedBody,
2027
- errorCode
2028
- });
2029
- }
2030
- }, "de_ListBackendJobsCommandError");
2031
1387
  var de_ListS3BucketsCommand = /* @__PURE__ */ __name(async (output, context) => {
2032
1388
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2033
- return de_ListS3BucketsCommandError(output, context);
1389
+ return de_CommandError(output, context);
2034
1390
  }
2035
1391
  const contents = (0, import_smithy_client.map)({
2036
1392
  $metadata: deserializeMetadata(output)
@@ -2043,37 +1399,9 @@ var de_ListS3BucketsCommand = /* @__PURE__ */ __name(async (output, context) =>
2043
1399
  Object.assign(contents, doc);
2044
1400
  return contents;
2045
1401
  }, "de_ListS3BucketsCommand");
2046
- var de_ListS3BucketsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2047
- const parsedOutput = {
2048
- ...output,
2049
- body: await parseErrorBody(output.body, context)
2050
- };
2051
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2052
- switch (errorCode) {
2053
- case "BadRequestException":
2054
- case "com.amazonaws.amplifybackend#BadRequestException":
2055
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2056
- case "GatewayTimeoutException":
2057
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
2058
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
2059
- case "NotFoundException":
2060
- case "com.amazonaws.amplifybackend#NotFoundException":
2061
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2062
- case "TooManyRequestsException":
2063
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
2064
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2065
- default:
2066
- const parsedBody = parsedOutput.body;
2067
- return throwDefaultError({
2068
- output,
2069
- parsedBody,
2070
- errorCode
2071
- });
2072
- }
2073
- }, "de_ListS3BucketsCommandError");
2074
1402
  var de_RemoveAllBackendsCommand = /* @__PURE__ */ __name(async (output, context) => {
2075
1403
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2076
- return de_RemoveAllBackendsCommandError(output, context);
1404
+ return de_CommandError(output, context);
2077
1405
  }
2078
1406
  const contents = (0, import_smithy_client.map)({
2079
1407
  $metadata: deserializeMetadata(output)
@@ -2089,37 +1417,9 @@ var de_RemoveAllBackendsCommand = /* @__PURE__ */ __name(async (output, context)
2089
1417
  Object.assign(contents, doc);
2090
1418
  return contents;
2091
1419
  }, "de_RemoveAllBackendsCommand");
2092
- var de_RemoveAllBackendsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2093
- const parsedOutput = {
2094
- ...output,
2095
- body: await parseErrorBody(output.body, context)
2096
- };
2097
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2098
- switch (errorCode) {
2099
- case "BadRequestException":
2100
- case "com.amazonaws.amplifybackend#BadRequestException":
2101
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2102
- case "GatewayTimeoutException":
2103
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
2104
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
2105
- case "NotFoundException":
2106
- case "com.amazonaws.amplifybackend#NotFoundException":
2107
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2108
- case "TooManyRequestsException":
2109
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
2110
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2111
- default:
2112
- const parsedBody = parsedOutput.body;
2113
- return throwDefaultError({
2114
- output,
2115
- parsedBody,
2116
- errorCode
2117
- });
2118
- }
2119
- }, "de_RemoveAllBackendsCommandError");
2120
1420
  var de_RemoveBackendConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
2121
1421
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2122
- return de_RemoveBackendConfigCommandError(output, context);
1422
+ return de_CommandError(output, context);
2123
1423
  }
2124
1424
  const contents = (0, import_smithy_client.map)({
2125
1425
  $metadata: deserializeMetadata(output)
@@ -2131,37 +1431,9 @@ var de_RemoveBackendConfigCommand = /* @__PURE__ */ __name(async (output, contex
2131
1431
  Object.assign(contents, doc);
2132
1432
  return contents;
2133
1433
  }, "de_RemoveBackendConfigCommand");
2134
- var de_RemoveBackendConfigCommandError = /* @__PURE__ */ __name(async (output, context) => {
2135
- const parsedOutput = {
2136
- ...output,
2137
- body: await parseErrorBody(output.body, context)
2138
- };
2139
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2140
- switch (errorCode) {
2141
- case "BadRequestException":
2142
- case "com.amazonaws.amplifybackend#BadRequestException":
2143
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2144
- case "GatewayTimeoutException":
2145
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
2146
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
2147
- case "NotFoundException":
2148
- case "com.amazonaws.amplifybackend#NotFoundException":
2149
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2150
- case "TooManyRequestsException":
2151
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
2152
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2153
- default:
2154
- const parsedBody = parsedOutput.body;
2155
- return throwDefaultError({
2156
- output,
2157
- parsedBody,
2158
- errorCode
2159
- });
2160
- }
2161
- }, "de_RemoveBackendConfigCommandError");
2162
1434
  var de_UpdateBackendAPICommand = /* @__PURE__ */ __name(async (output, context) => {
2163
1435
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2164
- return de_UpdateBackendAPICommandError(output, context);
1436
+ return de_CommandError(output, context);
2165
1437
  }
2166
1438
  const contents = (0, import_smithy_client.map)({
2167
1439
  $metadata: deserializeMetadata(output)
@@ -2178,37 +1450,9 @@ var de_UpdateBackendAPICommand = /* @__PURE__ */ __name(async (output, context)
2178
1450
  Object.assign(contents, doc);
2179
1451
  return contents;
2180
1452
  }, "de_UpdateBackendAPICommand");
2181
- var de_UpdateBackendAPICommandError = /* @__PURE__ */ __name(async (output, context) => {
2182
- const parsedOutput = {
2183
- ...output,
2184
- body: await parseErrorBody(output.body, context)
2185
- };
2186
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2187
- switch (errorCode) {
2188
- case "BadRequestException":
2189
- case "com.amazonaws.amplifybackend#BadRequestException":
2190
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2191
- case "GatewayTimeoutException":
2192
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
2193
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
2194
- case "NotFoundException":
2195
- case "com.amazonaws.amplifybackend#NotFoundException":
2196
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2197
- case "TooManyRequestsException":
2198
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
2199
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2200
- default:
2201
- const parsedBody = parsedOutput.body;
2202
- return throwDefaultError({
2203
- output,
2204
- parsedBody,
2205
- errorCode
2206
- });
2207
- }
2208
- }, "de_UpdateBackendAPICommandError");
2209
1453
  var de_UpdateBackendAuthCommand = /* @__PURE__ */ __name(async (output, context) => {
2210
1454
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2211
- return de_UpdateBackendAuthCommandError(output, context);
1455
+ return de_CommandError(output, context);
2212
1456
  }
2213
1457
  const contents = (0, import_smithy_client.map)({
2214
1458
  $metadata: deserializeMetadata(output)
@@ -2225,37 +1469,9 @@ var de_UpdateBackendAuthCommand = /* @__PURE__ */ __name(async (output, context)
2225
1469
  Object.assign(contents, doc);
2226
1470
  return contents;
2227
1471
  }, "de_UpdateBackendAuthCommand");
2228
- var de_UpdateBackendAuthCommandError = /* @__PURE__ */ __name(async (output, context) => {
2229
- const parsedOutput = {
2230
- ...output,
2231
- body: await parseErrorBody(output.body, context)
2232
- };
2233
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2234
- switch (errorCode) {
2235
- case "BadRequestException":
2236
- case "com.amazonaws.amplifybackend#BadRequestException":
2237
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2238
- case "GatewayTimeoutException":
2239
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
2240
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
2241
- case "NotFoundException":
2242
- case "com.amazonaws.amplifybackend#NotFoundException":
2243
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2244
- case "TooManyRequestsException":
2245
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
2246
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2247
- default:
2248
- const parsedBody = parsedOutput.body;
2249
- return throwDefaultError({
2250
- output,
2251
- parsedBody,
2252
- errorCode
2253
- });
2254
- }
2255
- }, "de_UpdateBackendAuthCommandError");
2256
1472
  var de_UpdateBackendConfigCommand = /* @__PURE__ */ __name(async (output, context) => {
2257
1473
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2258
- return de_UpdateBackendConfigCommandError(output, context);
1474
+ return de_CommandError(output, context);
2259
1475
  }
2260
1476
  const contents = (0, import_smithy_client.map)({
2261
1477
  $metadata: deserializeMetadata(output)
@@ -2270,37 +1486,9 @@ var de_UpdateBackendConfigCommand = /* @__PURE__ */ __name(async (output, contex
2270
1486
  Object.assign(contents, doc);
2271
1487
  return contents;
2272
1488
  }, "de_UpdateBackendConfigCommand");
2273
- var de_UpdateBackendConfigCommandError = /* @__PURE__ */ __name(async (output, context) => {
2274
- const parsedOutput = {
2275
- ...output,
2276
- body: await parseErrorBody(output.body, context)
2277
- };
2278
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2279
- switch (errorCode) {
2280
- case "BadRequestException":
2281
- case "com.amazonaws.amplifybackend#BadRequestException":
2282
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2283
- case "GatewayTimeoutException":
2284
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
2285
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
2286
- case "NotFoundException":
2287
- case "com.amazonaws.amplifybackend#NotFoundException":
2288
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2289
- case "TooManyRequestsException":
2290
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
2291
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2292
- default:
2293
- const parsedBody = parsedOutput.body;
2294
- return throwDefaultError({
2295
- output,
2296
- parsedBody,
2297
- errorCode
2298
- });
2299
- }
2300
- }, "de_UpdateBackendConfigCommandError");
2301
1489
  var de_UpdateBackendJobCommand = /* @__PURE__ */ __name(async (output, context) => {
2302
1490
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2303
- return de_UpdateBackendJobCommandError(output, context);
1491
+ return de_CommandError(output, context);
2304
1492
  }
2305
1493
  const contents = (0, import_smithy_client.map)({
2306
1494
  $metadata: deserializeMetadata(output)
@@ -2319,37 +1507,9 @@ var de_UpdateBackendJobCommand = /* @__PURE__ */ __name(async (output, context)
2319
1507
  Object.assign(contents, doc);
2320
1508
  return contents;
2321
1509
  }, "de_UpdateBackendJobCommand");
2322
- var de_UpdateBackendJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
2323
- const parsedOutput = {
2324
- ...output,
2325
- body: await parseErrorBody(output.body, context)
2326
- };
2327
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2328
- switch (errorCode) {
2329
- case "BadRequestException":
2330
- case "com.amazonaws.amplifybackend#BadRequestException":
2331
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2332
- case "GatewayTimeoutException":
2333
- case "com.amazonaws.amplifybackend#GatewayTimeoutException":
2334
- throw await de_GatewayTimeoutExceptionRes(parsedOutput, context);
2335
- case "NotFoundException":
2336
- case "com.amazonaws.amplifybackend#NotFoundException":
2337
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2338
- case "TooManyRequestsException":
2339
- case "com.amazonaws.amplifybackend#TooManyRequestsException":
2340
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2341
- default:
2342
- const parsedBody = parsedOutput.body;
2343
- return throwDefaultError({
2344
- output,
2345
- parsedBody,
2346
- errorCode
2347
- });
2348
- }
2349
- }, "de_UpdateBackendJobCommandError");
2350
1510
  var de_UpdateBackendStorageCommand = /* @__PURE__ */ __name(async (output, context) => {
2351
1511
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2352
- return de_UpdateBackendStorageCommandError(output, context);
1512
+ return de_CommandError(output, context);
2353
1513
  }
2354
1514
  const contents = (0, import_smithy_client.map)({
2355
1515
  $metadata: deserializeMetadata(output)
@@ -2364,7 +1524,7 @@ var de_UpdateBackendStorageCommand = /* @__PURE__ */ __name(async (output, conte
2364
1524
  Object.assign(contents, doc);
2365
1525
  return contents;
2366
1526
  }, "de_UpdateBackendStorageCommand");
2367
- var de_UpdateBackendStorageCommandError = /* @__PURE__ */ __name(async (output, context) => {
1527
+ var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
2368
1528
  const parsedOutput = {
2369
1529
  ...output,
2370
1530
  body: await parseErrorBody(output.body, context)
@@ -2391,7 +1551,7 @@ var de_UpdateBackendStorageCommandError = /* @__PURE__ */ __name(async (output,
2391
1551
  errorCode
2392
1552
  });
2393
1553
  }
2394
- }, "de_UpdateBackendStorageCommandError");
1554
+ }, "de_CommandError");
2395
1555
  var throwDefaultError = (0, import_smithy_client.withBaseException)(AmplifyBackendServiceException);
2396
1556
  var de_BadRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
2397
1557
  const contents = (0, import_smithy_client.map)({});