@aws-sdk/client-storage-gateway 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.
package/dist-cjs/index.js CHANGED
@@ -1035,7 +1035,7 @@ var se_UpdateVTLDeviceTypeCommand = /* @__PURE__ */ __name(async (input, context
1035
1035
  }, "se_UpdateVTLDeviceTypeCommand");
1036
1036
  var de_ActivateGatewayCommand = /* @__PURE__ */ __name(async (output, context) => {
1037
1037
  if (output.statusCode >= 300) {
1038
- return de_ActivateGatewayCommandError(output, context);
1038
+ return de_CommandError(output, context);
1039
1039
  }
1040
1040
  const data = await parseBody(output.body, context);
1041
1041
  let contents = {};
@@ -1046,31 +1046,9 @@ var de_ActivateGatewayCommand = /* @__PURE__ */ __name(async (output, context) =
1046
1046
  };
1047
1047
  return response;
1048
1048
  }, "de_ActivateGatewayCommand");
1049
- var de_ActivateGatewayCommandError = /* @__PURE__ */ __name(async (output, context) => {
1050
- const parsedOutput = {
1051
- ...output,
1052
- body: await parseErrorBody(output.body, context)
1053
- };
1054
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1055
- switch (errorCode) {
1056
- case "InternalServerError":
1057
- case "com.amazonaws.storagegateway#InternalServerError":
1058
- throw await de_InternalServerErrorRes(parsedOutput, context);
1059
- case "InvalidGatewayRequestException":
1060
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1061
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1062
- default:
1063
- const parsedBody = parsedOutput.body;
1064
- return throwDefaultError({
1065
- output,
1066
- parsedBody,
1067
- errorCode
1068
- });
1069
- }
1070
- }, "de_ActivateGatewayCommandError");
1071
1049
  var de_AddCacheCommand = /* @__PURE__ */ __name(async (output, context) => {
1072
1050
  if (output.statusCode >= 300) {
1073
- return de_AddCacheCommandError(output, context);
1051
+ return de_CommandError(output, context);
1074
1052
  }
1075
1053
  const data = await parseBody(output.body, context);
1076
1054
  let contents = {};
@@ -1081,31 +1059,9 @@ var de_AddCacheCommand = /* @__PURE__ */ __name(async (output, context) => {
1081
1059
  };
1082
1060
  return response;
1083
1061
  }, "de_AddCacheCommand");
1084
- var de_AddCacheCommandError = /* @__PURE__ */ __name(async (output, context) => {
1085
- const parsedOutput = {
1086
- ...output,
1087
- body: await parseErrorBody(output.body, context)
1088
- };
1089
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1090
- switch (errorCode) {
1091
- case "InternalServerError":
1092
- case "com.amazonaws.storagegateway#InternalServerError":
1093
- throw await de_InternalServerErrorRes(parsedOutput, context);
1094
- case "InvalidGatewayRequestException":
1095
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1096
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1097
- default:
1098
- const parsedBody = parsedOutput.body;
1099
- return throwDefaultError({
1100
- output,
1101
- parsedBody,
1102
- errorCode
1103
- });
1104
- }
1105
- }, "de_AddCacheCommandError");
1106
1062
  var de_AddTagsToResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
1107
1063
  if (output.statusCode >= 300) {
1108
- return de_AddTagsToResourceCommandError(output, context);
1064
+ return de_CommandError(output, context);
1109
1065
  }
1110
1066
  const data = await parseBody(output.body, context);
1111
1067
  let contents = {};
@@ -1116,31 +1072,9 @@ var de_AddTagsToResourceCommand = /* @__PURE__ */ __name(async (output, context)
1116
1072
  };
1117
1073
  return response;
1118
1074
  }, "de_AddTagsToResourceCommand");
1119
- var de_AddTagsToResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
1120
- const parsedOutput = {
1121
- ...output,
1122
- body: await parseErrorBody(output.body, context)
1123
- };
1124
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1125
- switch (errorCode) {
1126
- case "InternalServerError":
1127
- case "com.amazonaws.storagegateway#InternalServerError":
1128
- throw await de_InternalServerErrorRes(parsedOutput, context);
1129
- case "InvalidGatewayRequestException":
1130
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1131
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1132
- default:
1133
- const parsedBody = parsedOutput.body;
1134
- return throwDefaultError({
1135
- output,
1136
- parsedBody,
1137
- errorCode
1138
- });
1139
- }
1140
- }, "de_AddTagsToResourceCommandError");
1141
1075
  var de_AddUploadBufferCommand = /* @__PURE__ */ __name(async (output, context) => {
1142
1076
  if (output.statusCode >= 300) {
1143
- return de_AddUploadBufferCommandError(output, context);
1077
+ return de_CommandError(output, context);
1144
1078
  }
1145
1079
  const data = await parseBody(output.body, context);
1146
1080
  let contents = {};
@@ -1151,31 +1085,9 @@ var de_AddUploadBufferCommand = /* @__PURE__ */ __name(async (output, context) =
1151
1085
  };
1152
1086
  return response;
1153
1087
  }, "de_AddUploadBufferCommand");
1154
- var de_AddUploadBufferCommandError = /* @__PURE__ */ __name(async (output, context) => {
1155
- const parsedOutput = {
1156
- ...output,
1157
- body: await parseErrorBody(output.body, context)
1158
- };
1159
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1160
- switch (errorCode) {
1161
- case "InternalServerError":
1162
- case "com.amazonaws.storagegateway#InternalServerError":
1163
- throw await de_InternalServerErrorRes(parsedOutput, context);
1164
- case "InvalidGatewayRequestException":
1165
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1166
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1167
- default:
1168
- const parsedBody = parsedOutput.body;
1169
- return throwDefaultError({
1170
- output,
1171
- parsedBody,
1172
- errorCode
1173
- });
1174
- }
1175
- }, "de_AddUploadBufferCommandError");
1176
1088
  var de_AddWorkingStorageCommand = /* @__PURE__ */ __name(async (output, context) => {
1177
1089
  if (output.statusCode >= 300) {
1178
- return de_AddWorkingStorageCommandError(output, context);
1090
+ return de_CommandError(output, context);
1179
1091
  }
1180
1092
  const data = await parseBody(output.body, context);
1181
1093
  let contents = {};
@@ -1186,31 +1098,9 @@ var de_AddWorkingStorageCommand = /* @__PURE__ */ __name(async (output, context)
1186
1098
  };
1187
1099
  return response;
1188
1100
  }, "de_AddWorkingStorageCommand");
1189
- var de_AddWorkingStorageCommandError = /* @__PURE__ */ __name(async (output, context) => {
1190
- const parsedOutput = {
1191
- ...output,
1192
- body: await parseErrorBody(output.body, context)
1193
- };
1194
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1195
- switch (errorCode) {
1196
- case "InternalServerError":
1197
- case "com.amazonaws.storagegateway#InternalServerError":
1198
- throw await de_InternalServerErrorRes(parsedOutput, context);
1199
- case "InvalidGatewayRequestException":
1200
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1201
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1202
- default:
1203
- const parsedBody = parsedOutput.body;
1204
- return throwDefaultError({
1205
- output,
1206
- parsedBody,
1207
- errorCode
1208
- });
1209
- }
1210
- }, "de_AddWorkingStorageCommandError");
1211
1101
  var de_AssignTapePoolCommand = /* @__PURE__ */ __name(async (output, context) => {
1212
1102
  if (output.statusCode >= 300) {
1213
- return de_AssignTapePoolCommandError(output, context);
1103
+ return de_CommandError(output, context);
1214
1104
  }
1215
1105
  const data = await parseBody(output.body, context);
1216
1106
  let contents = {};
@@ -1221,31 +1111,9 @@ var de_AssignTapePoolCommand = /* @__PURE__ */ __name(async (output, context) =>
1221
1111
  };
1222
1112
  return response;
1223
1113
  }, "de_AssignTapePoolCommand");
1224
- var de_AssignTapePoolCommandError = /* @__PURE__ */ __name(async (output, context) => {
1225
- const parsedOutput = {
1226
- ...output,
1227
- body: await parseErrorBody(output.body, context)
1228
- };
1229
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1230
- switch (errorCode) {
1231
- case "InternalServerError":
1232
- case "com.amazonaws.storagegateway#InternalServerError":
1233
- throw await de_InternalServerErrorRes(parsedOutput, context);
1234
- case "InvalidGatewayRequestException":
1235
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1236
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1237
- default:
1238
- const parsedBody = parsedOutput.body;
1239
- return throwDefaultError({
1240
- output,
1241
- parsedBody,
1242
- errorCode
1243
- });
1244
- }
1245
- }, "de_AssignTapePoolCommandError");
1246
1114
  var de_AssociateFileSystemCommand = /* @__PURE__ */ __name(async (output, context) => {
1247
1115
  if (output.statusCode >= 300) {
1248
- return de_AssociateFileSystemCommandError(output, context);
1116
+ return de_CommandError(output, context);
1249
1117
  }
1250
1118
  const data = await parseBody(output.body, context);
1251
1119
  let contents = {};
@@ -1256,31 +1124,9 @@ var de_AssociateFileSystemCommand = /* @__PURE__ */ __name(async (output, contex
1256
1124
  };
1257
1125
  return response;
1258
1126
  }, "de_AssociateFileSystemCommand");
1259
- var de_AssociateFileSystemCommandError = /* @__PURE__ */ __name(async (output, context) => {
1260
- const parsedOutput = {
1261
- ...output,
1262
- body: await parseErrorBody(output.body, context)
1263
- };
1264
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1265
- switch (errorCode) {
1266
- case "InternalServerError":
1267
- case "com.amazonaws.storagegateway#InternalServerError":
1268
- throw await de_InternalServerErrorRes(parsedOutput, context);
1269
- case "InvalidGatewayRequestException":
1270
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1271
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1272
- default:
1273
- const parsedBody = parsedOutput.body;
1274
- return throwDefaultError({
1275
- output,
1276
- parsedBody,
1277
- errorCode
1278
- });
1279
- }
1280
- }, "de_AssociateFileSystemCommandError");
1281
1127
  var de_AttachVolumeCommand = /* @__PURE__ */ __name(async (output, context) => {
1282
1128
  if (output.statusCode >= 300) {
1283
- return de_AttachVolumeCommandError(output, context);
1129
+ return de_CommandError(output, context);
1284
1130
  }
1285
1131
  const data = await parseBody(output.body, context);
1286
1132
  let contents = {};
@@ -1291,31 +1137,9 @@ var de_AttachVolumeCommand = /* @__PURE__ */ __name(async (output, context) => {
1291
1137
  };
1292
1138
  return response;
1293
1139
  }, "de_AttachVolumeCommand");
1294
- var de_AttachVolumeCommandError = /* @__PURE__ */ __name(async (output, context) => {
1295
- const parsedOutput = {
1296
- ...output,
1297
- body: await parseErrorBody(output.body, context)
1298
- };
1299
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1300
- switch (errorCode) {
1301
- case "InternalServerError":
1302
- case "com.amazonaws.storagegateway#InternalServerError":
1303
- throw await de_InternalServerErrorRes(parsedOutput, context);
1304
- case "InvalidGatewayRequestException":
1305
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1306
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1307
- default:
1308
- const parsedBody = parsedOutput.body;
1309
- return throwDefaultError({
1310
- output,
1311
- parsedBody,
1312
- errorCode
1313
- });
1314
- }
1315
- }, "de_AttachVolumeCommandError");
1316
1140
  var de_CancelArchivalCommand = /* @__PURE__ */ __name(async (output, context) => {
1317
1141
  if (output.statusCode >= 300) {
1318
- return de_CancelArchivalCommandError(output, context);
1142
+ return de_CommandError(output, context);
1319
1143
  }
1320
1144
  const data = await parseBody(output.body, context);
1321
1145
  let contents = {};
@@ -1326,31 +1150,9 @@ var de_CancelArchivalCommand = /* @__PURE__ */ __name(async (output, context) =>
1326
1150
  };
1327
1151
  return response;
1328
1152
  }, "de_CancelArchivalCommand");
1329
- var de_CancelArchivalCommandError = /* @__PURE__ */ __name(async (output, context) => {
1330
- const parsedOutput = {
1331
- ...output,
1332
- body: await parseErrorBody(output.body, context)
1333
- };
1334
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1335
- switch (errorCode) {
1336
- case "InternalServerError":
1337
- case "com.amazonaws.storagegateway#InternalServerError":
1338
- throw await de_InternalServerErrorRes(parsedOutput, context);
1339
- case "InvalidGatewayRequestException":
1340
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1341
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1342
- default:
1343
- const parsedBody = parsedOutput.body;
1344
- return throwDefaultError({
1345
- output,
1346
- parsedBody,
1347
- errorCode
1348
- });
1349
- }
1350
- }, "de_CancelArchivalCommandError");
1351
1153
  var de_CancelRetrievalCommand = /* @__PURE__ */ __name(async (output, context) => {
1352
1154
  if (output.statusCode >= 300) {
1353
- return de_CancelRetrievalCommandError(output, context);
1155
+ return de_CommandError(output, context);
1354
1156
  }
1355
1157
  const data = await parseBody(output.body, context);
1356
1158
  let contents = {};
@@ -1361,31 +1163,9 @@ var de_CancelRetrievalCommand = /* @__PURE__ */ __name(async (output, context) =
1361
1163
  };
1362
1164
  return response;
1363
1165
  }, "de_CancelRetrievalCommand");
1364
- var de_CancelRetrievalCommandError = /* @__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 "InternalServerError":
1372
- case "com.amazonaws.storagegateway#InternalServerError":
1373
- throw await de_InternalServerErrorRes(parsedOutput, context);
1374
- case "InvalidGatewayRequestException":
1375
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1376
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1377
- default:
1378
- const parsedBody = parsedOutput.body;
1379
- return throwDefaultError({
1380
- output,
1381
- parsedBody,
1382
- errorCode
1383
- });
1384
- }
1385
- }, "de_CancelRetrievalCommandError");
1386
1166
  var de_CreateCachediSCSIVolumeCommand = /* @__PURE__ */ __name(async (output, context) => {
1387
1167
  if (output.statusCode >= 300) {
1388
- return de_CreateCachediSCSIVolumeCommandError(output, context);
1168
+ return de_CommandError(output, context);
1389
1169
  }
1390
1170
  const data = await parseBody(output.body, context);
1391
1171
  let contents = {};
@@ -1396,31 +1176,9 @@ var de_CreateCachediSCSIVolumeCommand = /* @__PURE__ */ __name(async (output, co
1396
1176
  };
1397
1177
  return response;
1398
1178
  }, "de_CreateCachediSCSIVolumeCommand");
1399
- var de_CreateCachediSCSIVolumeCommandError = /* @__PURE__ */ __name(async (output, context) => {
1400
- const parsedOutput = {
1401
- ...output,
1402
- body: await parseErrorBody(output.body, context)
1403
- };
1404
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1405
- switch (errorCode) {
1406
- case "InternalServerError":
1407
- case "com.amazonaws.storagegateway#InternalServerError":
1408
- throw await de_InternalServerErrorRes(parsedOutput, context);
1409
- case "InvalidGatewayRequestException":
1410
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1411
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1412
- default:
1413
- const parsedBody = parsedOutput.body;
1414
- return throwDefaultError({
1415
- output,
1416
- parsedBody,
1417
- errorCode
1418
- });
1419
- }
1420
- }, "de_CreateCachediSCSIVolumeCommandError");
1421
1179
  var de_CreateNFSFileShareCommand = /* @__PURE__ */ __name(async (output, context) => {
1422
1180
  if (output.statusCode >= 300) {
1423
- return de_CreateNFSFileShareCommandError(output, context);
1181
+ return de_CommandError(output, context);
1424
1182
  }
1425
1183
  const data = await parseBody(output.body, context);
1426
1184
  let contents = {};
@@ -1431,31 +1189,9 @@ var de_CreateNFSFileShareCommand = /* @__PURE__ */ __name(async (output, context
1431
1189
  };
1432
1190
  return response;
1433
1191
  }, "de_CreateNFSFileShareCommand");
1434
- var de_CreateNFSFileShareCommandError = /* @__PURE__ */ __name(async (output, context) => {
1435
- const parsedOutput = {
1436
- ...output,
1437
- body: await parseErrorBody(output.body, context)
1438
- };
1439
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1440
- switch (errorCode) {
1441
- case "InternalServerError":
1442
- case "com.amazonaws.storagegateway#InternalServerError":
1443
- throw await de_InternalServerErrorRes(parsedOutput, context);
1444
- case "InvalidGatewayRequestException":
1445
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1446
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1447
- default:
1448
- const parsedBody = parsedOutput.body;
1449
- return throwDefaultError({
1450
- output,
1451
- parsedBody,
1452
- errorCode
1453
- });
1454
- }
1455
- }, "de_CreateNFSFileShareCommandError");
1456
1192
  var de_CreateSMBFileShareCommand = /* @__PURE__ */ __name(async (output, context) => {
1457
1193
  if (output.statusCode >= 300) {
1458
- return de_CreateSMBFileShareCommandError(output, context);
1194
+ return de_CommandError(output, context);
1459
1195
  }
1460
1196
  const data = await parseBody(output.body, context);
1461
1197
  let contents = {};
@@ -1466,69 +1202,22 @@ var de_CreateSMBFileShareCommand = /* @__PURE__ */ __name(async (output, context
1466
1202
  };
1467
1203
  return response;
1468
1204
  }, "de_CreateSMBFileShareCommand");
1469
- var de_CreateSMBFileShareCommandError = /* @__PURE__ */ __name(async (output, context) => {
1470
- const parsedOutput = {
1471
- ...output,
1472
- body: await parseErrorBody(output.body, context)
1473
- };
1474
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1475
- switch (errorCode) {
1476
- case "InternalServerError":
1477
- case "com.amazonaws.storagegateway#InternalServerError":
1478
- throw await de_InternalServerErrorRes(parsedOutput, context);
1479
- case "InvalidGatewayRequestException":
1480
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1481
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1482
- default:
1483
- const parsedBody = parsedOutput.body;
1484
- return throwDefaultError({
1485
- output,
1486
- parsedBody,
1487
- errorCode
1488
- });
1489
- }
1490
- }, "de_CreateSMBFileShareCommandError");
1491
- var de_CreateSnapshotCommand = /* @__PURE__ */ __name(async (output, context) => {
1492
- if (output.statusCode >= 300) {
1493
- return de_CreateSnapshotCommandError(output, context);
1494
- }
1495
- const data = await parseBody(output.body, context);
1496
- let contents = {};
1497
- contents = (0, import_smithy_client._json)(data);
1498
- const response = {
1499
- $metadata: deserializeMetadata(output),
1500
- ...contents
1205
+ var de_CreateSnapshotCommand = /* @__PURE__ */ __name(async (output, context) => {
1206
+ if (output.statusCode >= 300) {
1207
+ return de_CommandError(output, context);
1208
+ }
1209
+ const data = await parseBody(output.body, context);
1210
+ let contents = {};
1211
+ contents = (0, import_smithy_client._json)(data);
1212
+ const response = {
1213
+ $metadata: deserializeMetadata(output),
1214
+ ...contents
1501
1215
  };
1502
1216
  return response;
1503
1217
  }, "de_CreateSnapshotCommand");
1504
- var de_CreateSnapshotCommandError = /* @__PURE__ */ __name(async (output, context) => {
1505
- const parsedOutput = {
1506
- ...output,
1507
- body: await parseErrorBody(output.body, context)
1508
- };
1509
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1510
- switch (errorCode) {
1511
- case "InternalServerError":
1512
- case "com.amazonaws.storagegateway#InternalServerError":
1513
- throw await de_InternalServerErrorRes(parsedOutput, context);
1514
- case "InvalidGatewayRequestException":
1515
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1516
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1517
- case "ServiceUnavailableError":
1518
- case "com.amazonaws.storagegateway#ServiceUnavailableError":
1519
- throw await de_ServiceUnavailableErrorRes(parsedOutput, context);
1520
- default:
1521
- const parsedBody = parsedOutput.body;
1522
- return throwDefaultError({
1523
- output,
1524
- parsedBody,
1525
- errorCode
1526
- });
1527
- }
1528
- }, "de_CreateSnapshotCommandError");
1529
1218
  var de_CreateSnapshotFromVolumeRecoveryPointCommand = /* @__PURE__ */ __name(async (output, context) => {
1530
1219
  if (output.statusCode >= 300) {
1531
- return de_CreateSnapshotFromVolumeRecoveryPointCommandError(output, context);
1220
+ return de_CommandError(output, context);
1532
1221
  }
1533
1222
  const data = await parseBody(output.body, context);
1534
1223
  let contents = {};
@@ -1539,34 +1228,9 @@ var de_CreateSnapshotFromVolumeRecoveryPointCommand = /* @__PURE__ */ __name(asy
1539
1228
  };
1540
1229
  return response;
1541
1230
  }, "de_CreateSnapshotFromVolumeRecoveryPointCommand");
1542
- var de_CreateSnapshotFromVolumeRecoveryPointCommandError = /* @__PURE__ */ __name(async (output, context) => {
1543
- const parsedOutput = {
1544
- ...output,
1545
- body: await parseErrorBody(output.body, context)
1546
- };
1547
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1548
- switch (errorCode) {
1549
- case "InternalServerError":
1550
- case "com.amazonaws.storagegateway#InternalServerError":
1551
- throw await de_InternalServerErrorRes(parsedOutput, context);
1552
- case "InvalidGatewayRequestException":
1553
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1554
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1555
- case "ServiceUnavailableError":
1556
- case "com.amazonaws.storagegateway#ServiceUnavailableError":
1557
- throw await de_ServiceUnavailableErrorRes(parsedOutput, context);
1558
- default:
1559
- const parsedBody = parsedOutput.body;
1560
- return throwDefaultError({
1561
- output,
1562
- parsedBody,
1563
- errorCode
1564
- });
1565
- }
1566
- }, "de_CreateSnapshotFromVolumeRecoveryPointCommandError");
1567
1231
  var de_CreateStorediSCSIVolumeCommand = /* @__PURE__ */ __name(async (output, context) => {
1568
1232
  if (output.statusCode >= 300) {
1569
- return de_CreateStorediSCSIVolumeCommandError(output, context);
1233
+ return de_CommandError(output, context);
1570
1234
  }
1571
1235
  const data = await parseBody(output.body, context);
1572
1236
  let contents = {};
@@ -1577,31 +1241,9 @@ var de_CreateStorediSCSIVolumeCommand = /* @__PURE__ */ __name(async (output, co
1577
1241
  };
1578
1242
  return response;
1579
1243
  }, "de_CreateStorediSCSIVolumeCommand");
1580
- var de_CreateStorediSCSIVolumeCommandError = /* @__PURE__ */ __name(async (output, context) => {
1581
- const parsedOutput = {
1582
- ...output,
1583
- body: await parseErrorBody(output.body, context)
1584
- };
1585
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1586
- switch (errorCode) {
1587
- case "InternalServerError":
1588
- case "com.amazonaws.storagegateway#InternalServerError":
1589
- throw await de_InternalServerErrorRes(parsedOutput, context);
1590
- case "InvalidGatewayRequestException":
1591
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1592
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1593
- default:
1594
- const parsedBody = parsedOutput.body;
1595
- return throwDefaultError({
1596
- output,
1597
- parsedBody,
1598
- errorCode
1599
- });
1600
- }
1601
- }, "de_CreateStorediSCSIVolumeCommandError");
1602
1244
  var de_CreateTapePoolCommand = /* @__PURE__ */ __name(async (output, context) => {
1603
1245
  if (output.statusCode >= 300) {
1604
- return de_CreateTapePoolCommandError(output, context);
1246
+ return de_CommandError(output, context);
1605
1247
  }
1606
1248
  const data = await parseBody(output.body, context);
1607
1249
  let contents = {};
@@ -1612,31 +1254,9 @@ var de_CreateTapePoolCommand = /* @__PURE__ */ __name(async (output, context) =>
1612
1254
  };
1613
1255
  return response;
1614
1256
  }, "de_CreateTapePoolCommand");
1615
- var de_CreateTapePoolCommandError = /* @__PURE__ */ __name(async (output, context) => {
1616
- const parsedOutput = {
1617
- ...output,
1618
- body: await parseErrorBody(output.body, context)
1619
- };
1620
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1621
- switch (errorCode) {
1622
- case "InternalServerError":
1623
- case "com.amazonaws.storagegateway#InternalServerError":
1624
- throw await de_InternalServerErrorRes(parsedOutput, context);
1625
- case "InvalidGatewayRequestException":
1626
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1627
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1628
- default:
1629
- const parsedBody = parsedOutput.body;
1630
- return throwDefaultError({
1631
- output,
1632
- parsedBody,
1633
- errorCode
1634
- });
1635
- }
1636
- }, "de_CreateTapePoolCommandError");
1637
1257
  var de_CreateTapesCommand = /* @__PURE__ */ __name(async (output, context) => {
1638
1258
  if (output.statusCode >= 300) {
1639
- return de_CreateTapesCommandError(output, context);
1259
+ return de_CommandError(output, context);
1640
1260
  }
1641
1261
  const data = await parseBody(output.body, context);
1642
1262
  let contents = {};
@@ -1647,31 +1267,9 @@ var de_CreateTapesCommand = /* @__PURE__ */ __name(async (output, context) => {
1647
1267
  };
1648
1268
  return response;
1649
1269
  }, "de_CreateTapesCommand");
1650
- var de_CreateTapesCommandError = /* @__PURE__ */ __name(async (output, context) => {
1651
- const parsedOutput = {
1652
- ...output,
1653
- body: await parseErrorBody(output.body, context)
1654
- };
1655
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1656
- switch (errorCode) {
1657
- case "InternalServerError":
1658
- case "com.amazonaws.storagegateway#InternalServerError":
1659
- throw await de_InternalServerErrorRes(parsedOutput, context);
1660
- case "InvalidGatewayRequestException":
1661
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1662
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1663
- default:
1664
- const parsedBody = parsedOutput.body;
1665
- return throwDefaultError({
1666
- output,
1667
- parsedBody,
1668
- errorCode
1669
- });
1670
- }
1671
- }, "de_CreateTapesCommandError");
1672
1270
  var de_CreateTapeWithBarcodeCommand = /* @__PURE__ */ __name(async (output, context) => {
1673
1271
  if (output.statusCode >= 300) {
1674
- return de_CreateTapeWithBarcodeCommandError(output, context);
1272
+ return de_CommandError(output, context);
1675
1273
  }
1676
1274
  const data = await parseBody(output.body, context);
1677
1275
  let contents = {};
@@ -1682,31 +1280,9 @@ var de_CreateTapeWithBarcodeCommand = /* @__PURE__ */ __name(async (output, cont
1682
1280
  };
1683
1281
  return response;
1684
1282
  }, "de_CreateTapeWithBarcodeCommand");
1685
- var de_CreateTapeWithBarcodeCommandError = /* @__PURE__ */ __name(async (output, context) => {
1686
- const parsedOutput = {
1687
- ...output,
1688
- body: await parseErrorBody(output.body, context)
1689
- };
1690
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1691
- switch (errorCode) {
1692
- case "InternalServerError":
1693
- case "com.amazonaws.storagegateway#InternalServerError":
1694
- throw await de_InternalServerErrorRes(parsedOutput, context);
1695
- case "InvalidGatewayRequestException":
1696
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1697
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1698
- default:
1699
- const parsedBody = parsedOutput.body;
1700
- return throwDefaultError({
1701
- output,
1702
- parsedBody,
1703
- errorCode
1704
- });
1705
- }
1706
- }, "de_CreateTapeWithBarcodeCommandError");
1707
1283
  var de_DeleteAutomaticTapeCreationPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
1708
1284
  if (output.statusCode >= 300) {
1709
- return de_DeleteAutomaticTapeCreationPolicyCommandError(output, context);
1285
+ return de_CommandError(output, context);
1710
1286
  }
1711
1287
  const data = await parseBody(output.body, context);
1712
1288
  let contents = {};
@@ -1717,31 +1293,9 @@ var de_DeleteAutomaticTapeCreationPolicyCommand = /* @__PURE__ */ __name(async (
1717
1293
  };
1718
1294
  return response;
1719
1295
  }, "de_DeleteAutomaticTapeCreationPolicyCommand");
1720
- var de_DeleteAutomaticTapeCreationPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
1721
- const parsedOutput = {
1722
- ...output,
1723
- body: await parseErrorBody(output.body, context)
1724
- };
1725
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1726
- switch (errorCode) {
1727
- case "InternalServerError":
1728
- case "com.amazonaws.storagegateway#InternalServerError":
1729
- throw await de_InternalServerErrorRes(parsedOutput, context);
1730
- case "InvalidGatewayRequestException":
1731
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1732
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1733
- default:
1734
- const parsedBody = parsedOutput.body;
1735
- return throwDefaultError({
1736
- output,
1737
- parsedBody,
1738
- errorCode
1739
- });
1740
- }
1741
- }, "de_DeleteAutomaticTapeCreationPolicyCommandError");
1742
1296
  var de_DeleteBandwidthRateLimitCommand = /* @__PURE__ */ __name(async (output, context) => {
1743
1297
  if (output.statusCode >= 300) {
1744
- return de_DeleteBandwidthRateLimitCommandError(output, context);
1298
+ return de_CommandError(output, context);
1745
1299
  }
1746
1300
  const data = await parseBody(output.body, context);
1747
1301
  let contents = {};
@@ -1752,31 +1306,9 @@ var de_DeleteBandwidthRateLimitCommand = /* @__PURE__ */ __name(async (output, c
1752
1306
  };
1753
1307
  return response;
1754
1308
  }, "de_DeleteBandwidthRateLimitCommand");
1755
- var de_DeleteBandwidthRateLimitCommandError = /* @__PURE__ */ __name(async (output, context) => {
1756
- const parsedOutput = {
1757
- ...output,
1758
- body: await parseErrorBody(output.body, context)
1759
- };
1760
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1761
- switch (errorCode) {
1762
- case "InternalServerError":
1763
- case "com.amazonaws.storagegateway#InternalServerError":
1764
- throw await de_InternalServerErrorRes(parsedOutput, context);
1765
- case "InvalidGatewayRequestException":
1766
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1767
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1768
- default:
1769
- const parsedBody = parsedOutput.body;
1770
- return throwDefaultError({
1771
- output,
1772
- parsedBody,
1773
- errorCode
1774
- });
1775
- }
1776
- }, "de_DeleteBandwidthRateLimitCommandError");
1777
1309
  var de_DeleteChapCredentialsCommand = /* @__PURE__ */ __name(async (output, context) => {
1778
1310
  if (output.statusCode >= 300) {
1779
- return de_DeleteChapCredentialsCommandError(output, context);
1311
+ return de_CommandError(output, context);
1780
1312
  }
1781
1313
  const data = await parseBody(output.body, context);
1782
1314
  let contents = {};
@@ -1787,31 +1319,9 @@ var de_DeleteChapCredentialsCommand = /* @__PURE__ */ __name(async (output, cont
1787
1319
  };
1788
1320
  return response;
1789
1321
  }, "de_DeleteChapCredentialsCommand");
1790
- var de_DeleteChapCredentialsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1791
- const parsedOutput = {
1792
- ...output,
1793
- body: await parseErrorBody(output.body, context)
1794
- };
1795
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1796
- switch (errorCode) {
1797
- case "InternalServerError":
1798
- case "com.amazonaws.storagegateway#InternalServerError":
1799
- throw await de_InternalServerErrorRes(parsedOutput, context);
1800
- case "InvalidGatewayRequestException":
1801
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1802
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1803
- default:
1804
- const parsedBody = parsedOutput.body;
1805
- return throwDefaultError({
1806
- output,
1807
- parsedBody,
1808
- errorCode
1809
- });
1810
- }
1811
- }, "de_DeleteChapCredentialsCommandError");
1812
1322
  var de_DeleteFileShareCommand = /* @__PURE__ */ __name(async (output, context) => {
1813
1323
  if (output.statusCode >= 300) {
1814
- return de_DeleteFileShareCommandError(output, context);
1324
+ return de_CommandError(output, context);
1815
1325
  }
1816
1326
  const data = await parseBody(output.body, context);
1817
1327
  let contents = {};
@@ -1822,31 +1332,9 @@ var de_DeleteFileShareCommand = /* @__PURE__ */ __name(async (output, context) =
1822
1332
  };
1823
1333
  return response;
1824
1334
  }, "de_DeleteFileShareCommand");
1825
- var de_DeleteFileShareCommandError = /* @__PURE__ */ __name(async (output, context) => {
1826
- const parsedOutput = {
1827
- ...output,
1828
- body: await parseErrorBody(output.body, context)
1829
- };
1830
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1831
- switch (errorCode) {
1832
- case "InternalServerError":
1833
- case "com.amazonaws.storagegateway#InternalServerError":
1834
- throw await de_InternalServerErrorRes(parsedOutput, context);
1835
- case "InvalidGatewayRequestException":
1836
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1837
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1838
- default:
1839
- const parsedBody = parsedOutput.body;
1840
- return throwDefaultError({
1841
- output,
1842
- parsedBody,
1843
- errorCode
1844
- });
1845
- }
1846
- }, "de_DeleteFileShareCommandError");
1847
1335
  var de_DeleteGatewayCommand = /* @__PURE__ */ __name(async (output, context) => {
1848
1336
  if (output.statusCode >= 300) {
1849
- return de_DeleteGatewayCommandError(output, context);
1337
+ return de_CommandError(output, context);
1850
1338
  }
1851
1339
  const data = await parseBody(output.body, context);
1852
1340
  let contents = {};
@@ -1857,31 +1345,9 @@ var de_DeleteGatewayCommand = /* @__PURE__ */ __name(async (output, context) =>
1857
1345
  };
1858
1346
  return response;
1859
1347
  }, "de_DeleteGatewayCommand");
1860
- var de_DeleteGatewayCommandError = /* @__PURE__ */ __name(async (output, context) => {
1861
- const parsedOutput = {
1862
- ...output,
1863
- body: await parseErrorBody(output.body, context)
1864
- };
1865
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1866
- switch (errorCode) {
1867
- case "InternalServerError":
1868
- case "com.amazonaws.storagegateway#InternalServerError":
1869
- throw await de_InternalServerErrorRes(parsedOutput, context);
1870
- case "InvalidGatewayRequestException":
1871
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1872
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1873
- default:
1874
- const parsedBody = parsedOutput.body;
1875
- return throwDefaultError({
1876
- output,
1877
- parsedBody,
1878
- errorCode
1879
- });
1880
- }
1881
- }, "de_DeleteGatewayCommandError");
1882
1348
  var de_DeleteSnapshotScheduleCommand = /* @__PURE__ */ __name(async (output, context) => {
1883
1349
  if (output.statusCode >= 300) {
1884
- return de_DeleteSnapshotScheduleCommandError(output, context);
1350
+ return de_CommandError(output, context);
1885
1351
  }
1886
1352
  const data = await parseBody(output.body, context);
1887
1353
  let contents = {};
@@ -1892,31 +1358,9 @@ var de_DeleteSnapshotScheduleCommand = /* @__PURE__ */ __name(async (output, con
1892
1358
  };
1893
1359
  return response;
1894
1360
  }, "de_DeleteSnapshotScheduleCommand");
1895
- var de_DeleteSnapshotScheduleCommandError = /* @__PURE__ */ __name(async (output, context) => {
1896
- const parsedOutput = {
1897
- ...output,
1898
- body: await parseErrorBody(output.body, context)
1899
- };
1900
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1901
- switch (errorCode) {
1902
- case "InternalServerError":
1903
- case "com.amazonaws.storagegateway#InternalServerError":
1904
- throw await de_InternalServerErrorRes(parsedOutput, context);
1905
- case "InvalidGatewayRequestException":
1906
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1907
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1908
- default:
1909
- const parsedBody = parsedOutput.body;
1910
- return throwDefaultError({
1911
- output,
1912
- parsedBody,
1913
- errorCode
1914
- });
1915
- }
1916
- }, "de_DeleteSnapshotScheduleCommandError");
1917
1361
  var de_DeleteTapeCommand = /* @__PURE__ */ __name(async (output, context) => {
1918
1362
  if (output.statusCode >= 300) {
1919
- return de_DeleteTapeCommandError(output, context);
1363
+ return de_CommandError(output, context);
1920
1364
  }
1921
1365
  const data = await parseBody(output.body, context);
1922
1366
  let contents = {};
@@ -1927,31 +1371,9 @@ var de_DeleteTapeCommand = /* @__PURE__ */ __name(async (output, context) => {
1927
1371
  };
1928
1372
  return response;
1929
1373
  }, "de_DeleteTapeCommand");
1930
- var de_DeleteTapeCommandError = /* @__PURE__ */ __name(async (output, context) => {
1931
- const parsedOutput = {
1932
- ...output,
1933
- body: await parseErrorBody(output.body, context)
1934
- };
1935
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1936
- switch (errorCode) {
1937
- case "InternalServerError":
1938
- case "com.amazonaws.storagegateway#InternalServerError":
1939
- throw await de_InternalServerErrorRes(parsedOutput, context);
1940
- case "InvalidGatewayRequestException":
1941
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1942
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1943
- default:
1944
- const parsedBody = parsedOutput.body;
1945
- return throwDefaultError({
1946
- output,
1947
- parsedBody,
1948
- errorCode
1949
- });
1950
- }
1951
- }, "de_DeleteTapeCommandError");
1952
1374
  var de_DeleteTapeArchiveCommand = /* @__PURE__ */ __name(async (output, context) => {
1953
1375
  if (output.statusCode >= 300) {
1954
- return de_DeleteTapeArchiveCommandError(output, context);
1376
+ return de_CommandError(output, context);
1955
1377
  }
1956
1378
  const data = await parseBody(output.body, context);
1957
1379
  let contents = {};
@@ -1962,31 +1384,9 @@ var de_DeleteTapeArchiveCommand = /* @__PURE__ */ __name(async (output, context)
1962
1384
  };
1963
1385
  return response;
1964
1386
  }, "de_DeleteTapeArchiveCommand");
1965
- var de_DeleteTapeArchiveCommandError = /* @__PURE__ */ __name(async (output, context) => {
1966
- const parsedOutput = {
1967
- ...output,
1968
- body: await parseErrorBody(output.body, context)
1969
- };
1970
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1971
- switch (errorCode) {
1972
- case "InternalServerError":
1973
- case "com.amazonaws.storagegateway#InternalServerError":
1974
- throw await de_InternalServerErrorRes(parsedOutput, context);
1975
- case "InvalidGatewayRequestException":
1976
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
1977
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
1978
- default:
1979
- const parsedBody = parsedOutput.body;
1980
- return throwDefaultError({
1981
- output,
1982
- parsedBody,
1983
- errorCode
1984
- });
1985
- }
1986
- }, "de_DeleteTapeArchiveCommandError");
1987
1387
  var de_DeleteTapePoolCommand = /* @__PURE__ */ __name(async (output, context) => {
1988
1388
  if (output.statusCode >= 300) {
1989
- return de_DeleteTapePoolCommandError(output, context);
1389
+ return de_CommandError(output, context);
1990
1390
  }
1991
1391
  const data = await parseBody(output.body, context);
1992
1392
  let contents = {};
@@ -1997,31 +1397,9 @@ var de_DeleteTapePoolCommand = /* @__PURE__ */ __name(async (output, context) =>
1997
1397
  };
1998
1398
  return response;
1999
1399
  }, "de_DeleteTapePoolCommand");
2000
- var de_DeleteTapePoolCommandError = /* @__PURE__ */ __name(async (output, context) => {
2001
- const parsedOutput = {
2002
- ...output,
2003
- body: await parseErrorBody(output.body, context)
2004
- };
2005
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2006
- switch (errorCode) {
2007
- case "InternalServerError":
2008
- case "com.amazonaws.storagegateway#InternalServerError":
2009
- throw await de_InternalServerErrorRes(parsedOutput, context);
2010
- case "InvalidGatewayRequestException":
2011
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2012
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2013
- default:
2014
- const parsedBody = parsedOutput.body;
2015
- return throwDefaultError({
2016
- output,
2017
- parsedBody,
2018
- errorCode
2019
- });
2020
- }
2021
- }, "de_DeleteTapePoolCommandError");
2022
1400
  var de_DeleteVolumeCommand = /* @__PURE__ */ __name(async (output, context) => {
2023
1401
  if (output.statusCode >= 300) {
2024
- return de_DeleteVolumeCommandError(output, context);
1402
+ return de_CommandError(output, context);
2025
1403
  }
2026
1404
  const data = await parseBody(output.body, context);
2027
1405
  let contents = {};
@@ -2032,31 +1410,9 @@ var de_DeleteVolumeCommand = /* @__PURE__ */ __name(async (output, context) => {
2032
1410
  };
2033
1411
  return response;
2034
1412
  }, "de_DeleteVolumeCommand");
2035
- var de_DeleteVolumeCommandError = /* @__PURE__ */ __name(async (output, context) => {
2036
- const parsedOutput = {
2037
- ...output,
2038
- body: await parseErrorBody(output.body, context)
2039
- };
2040
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2041
- switch (errorCode) {
2042
- case "InternalServerError":
2043
- case "com.amazonaws.storagegateway#InternalServerError":
2044
- throw await de_InternalServerErrorRes(parsedOutput, context);
2045
- case "InvalidGatewayRequestException":
2046
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2047
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2048
- default:
2049
- const parsedBody = parsedOutput.body;
2050
- return throwDefaultError({
2051
- output,
2052
- parsedBody,
2053
- errorCode
2054
- });
2055
- }
2056
- }, "de_DeleteVolumeCommandError");
2057
1413
  var de_DescribeAvailabilityMonitorTestCommand = /* @__PURE__ */ __name(async (output, context) => {
2058
1414
  if (output.statusCode >= 300) {
2059
- return de_DescribeAvailabilityMonitorTestCommandError(output, context);
1415
+ return de_CommandError(output, context);
2060
1416
  }
2061
1417
  const data = await parseBody(output.body, context);
2062
1418
  let contents = {};
@@ -2067,31 +1423,9 @@ var de_DescribeAvailabilityMonitorTestCommand = /* @__PURE__ */ __name(async (ou
2067
1423
  };
2068
1424
  return response;
2069
1425
  }, "de_DescribeAvailabilityMonitorTestCommand");
2070
- var de_DescribeAvailabilityMonitorTestCommandError = /* @__PURE__ */ __name(async (output, context) => {
2071
- const parsedOutput = {
2072
- ...output,
2073
- body: await parseErrorBody(output.body, context)
2074
- };
2075
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2076
- switch (errorCode) {
2077
- case "InternalServerError":
2078
- case "com.amazonaws.storagegateway#InternalServerError":
2079
- throw await de_InternalServerErrorRes(parsedOutput, context);
2080
- case "InvalidGatewayRequestException":
2081
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2082
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2083
- default:
2084
- const parsedBody = parsedOutput.body;
2085
- return throwDefaultError({
2086
- output,
2087
- parsedBody,
2088
- errorCode
2089
- });
2090
- }
2091
- }, "de_DescribeAvailabilityMonitorTestCommandError");
2092
1426
  var de_DescribeBandwidthRateLimitCommand = /* @__PURE__ */ __name(async (output, context) => {
2093
1427
  if (output.statusCode >= 300) {
2094
- return de_DescribeBandwidthRateLimitCommandError(output, context);
1428
+ return de_CommandError(output, context);
2095
1429
  }
2096
1430
  const data = await parseBody(output.body, context);
2097
1431
  let contents = {};
@@ -2102,31 +1436,9 @@ var de_DescribeBandwidthRateLimitCommand = /* @__PURE__ */ __name(async (output,
2102
1436
  };
2103
1437
  return response;
2104
1438
  }, "de_DescribeBandwidthRateLimitCommand");
2105
- var de_DescribeBandwidthRateLimitCommandError = /* @__PURE__ */ __name(async (output, context) => {
2106
- const parsedOutput = {
2107
- ...output,
2108
- body: await parseErrorBody(output.body, context)
2109
- };
2110
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2111
- switch (errorCode) {
2112
- case "InternalServerError":
2113
- case "com.amazonaws.storagegateway#InternalServerError":
2114
- throw await de_InternalServerErrorRes(parsedOutput, context);
2115
- case "InvalidGatewayRequestException":
2116
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2117
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2118
- default:
2119
- const parsedBody = parsedOutput.body;
2120
- return throwDefaultError({
2121
- output,
2122
- parsedBody,
2123
- errorCode
2124
- });
2125
- }
2126
- }, "de_DescribeBandwidthRateLimitCommandError");
2127
1439
  var de_DescribeBandwidthRateLimitScheduleCommand = /* @__PURE__ */ __name(async (output, context) => {
2128
1440
  if (output.statusCode >= 300) {
2129
- return de_DescribeBandwidthRateLimitScheduleCommandError(output, context);
1441
+ return de_CommandError(output, context);
2130
1442
  }
2131
1443
  const data = await parseBody(output.body, context);
2132
1444
  let contents = {};
@@ -2137,31 +1449,9 @@ var de_DescribeBandwidthRateLimitScheduleCommand = /* @__PURE__ */ __name(async
2137
1449
  };
2138
1450
  return response;
2139
1451
  }, "de_DescribeBandwidthRateLimitScheduleCommand");
2140
- var de_DescribeBandwidthRateLimitScheduleCommandError = /* @__PURE__ */ __name(async (output, context) => {
2141
- const parsedOutput = {
2142
- ...output,
2143
- body: await parseErrorBody(output.body, context)
2144
- };
2145
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2146
- switch (errorCode) {
2147
- case "InternalServerError":
2148
- case "com.amazonaws.storagegateway#InternalServerError":
2149
- throw await de_InternalServerErrorRes(parsedOutput, context);
2150
- case "InvalidGatewayRequestException":
2151
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2152
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2153
- default:
2154
- const parsedBody = parsedOutput.body;
2155
- return throwDefaultError({
2156
- output,
2157
- parsedBody,
2158
- errorCode
2159
- });
2160
- }
2161
- }, "de_DescribeBandwidthRateLimitScheduleCommandError");
2162
1452
  var de_DescribeCacheCommand = /* @__PURE__ */ __name(async (output, context) => {
2163
1453
  if (output.statusCode >= 300) {
2164
- return de_DescribeCacheCommandError(output, context);
1454
+ return de_CommandError(output, context);
2165
1455
  }
2166
1456
  const data = await parseBody(output.body, context);
2167
1457
  let contents = {};
@@ -2172,31 +1462,9 @@ var de_DescribeCacheCommand = /* @__PURE__ */ __name(async (output, context) =>
2172
1462
  };
2173
1463
  return response;
2174
1464
  }, "de_DescribeCacheCommand");
2175
- var de_DescribeCacheCommandError = /* @__PURE__ */ __name(async (output, context) => {
2176
- const parsedOutput = {
2177
- ...output,
2178
- body: await parseErrorBody(output.body, context)
2179
- };
2180
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2181
- switch (errorCode) {
2182
- case "InternalServerError":
2183
- case "com.amazonaws.storagegateway#InternalServerError":
2184
- throw await de_InternalServerErrorRes(parsedOutput, context);
2185
- case "InvalidGatewayRequestException":
2186
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2187
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2188
- default:
2189
- const parsedBody = parsedOutput.body;
2190
- return throwDefaultError({
2191
- output,
2192
- parsedBody,
2193
- errorCode
2194
- });
2195
- }
2196
- }, "de_DescribeCacheCommandError");
2197
1465
  var de_DescribeCachediSCSIVolumesCommand = /* @__PURE__ */ __name(async (output, context) => {
2198
1466
  if (output.statusCode >= 300) {
2199
- return de_DescribeCachediSCSIVolumesCommandError(output, context);
1467
+ return de_CommandError(output, context);
2200
1468
  }
2201
1469
  const data = await parseBody(output.body, context);
2202
1470
  let contents = {};
@@ -2207,31 +1475,9 @@ var de_DescribeCachediSCSIVolumesCommand = /* @__PURE__ */ __name(async (output,
2207
1475
  };
2208
1476
  return response;
2209
1477
  }, "de_DescribeCachediSCSIVolumesCommand");
2210
- var de_DescribeCachediSCSIVolumesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2211
- const parsedOutput = {
2212
- ...output,
2213
- body: await parseErrorBody(output.body, context)
2214
- };
2215
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2216
- switch (errorCode) {
2217
- case "InternalServerError":
2218
- case "com.amazonaws.storagegateway#InternalServerError":
2219
- throw await de_InternalServerErrorRes(parsedOutput, context);
2220
- case "InvalidGatewayRequestException":
2221
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2222
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2223
- default:
2224
- const parsedBody = parsedOutput.body;
2225
- return throwDefaultError({
2226
- output,
2227
- parsedBody,
2228
- errorCode
2229
- });
2230
- }
2231
- }, "de_DescribeCachediSCSIVolumesCommandError");
2232
1478
  var de_DescribeChapCredentialsCommand = /* @__PURE__ */ __name(async (output, context) => {
2233
1479
  if (output.statusCode >= 300) {
2234
- return de_DescribeChapCredentialsCommandError(output, context);
1480
+ return de_CommandError(output, context);
2235
1481
  }
2236
1482
  const data = await parseBody(output.body, context);
2237
1483
  let contents = {};
@@ -2242,31 +1488,9 @@ var de_DescribeChapCredentialsCommand = /* @__PURE__ */ __name(async (output, co
2242
1488
  };
2243
1489
  return response;
2244
1490
  }, "de_DescribeChapCredentialsCommand");
2245
- var de_DescribeChapCredentialsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2246
- const parsedOutput = {
2247
- ...output,
2248
- body: await parseErrorBody(output.body, context)
2249
- };
2250
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2251
- switch (errorCode) {
2252
- case "InternalServerError":
2253
- case "com.amazonaws.storagegateway#InternalServerError":
2254
- throw await de_InternalServerErrorRes(parsedOutput, context);
2255
- case "InvalidGatewayRequestException":
2256
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2257
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2258
- default:
2259
- const parsedBody = parsedOutput.body;
2260
- return throwDefaultError({
2261
- output,
2262
- parsedBody,
2263
- errorCode
2264
- });
2265
- }
2266
- }, "de_DescribeChapCredentialsCommandError");
2267
1491
  var de_DescribeFileSystemAssociationsCommand = /* @__PURE__ */ __name(async (output, context) => {
2268
1492
  if (output.statusCode >= 300) {
2269
- return de_DescribeFileSystemAssociationsCommandError(output, context);
1493
+ return de_CommandError(output, context);
2270
1494
  }
2271
1495
  const data = await parseBody(output.body, context);
2272
1496
  let contents = {};
@@ -2277,31 +1501,9 @@ var de_DescribeFileSystemAssociationsCommand = /* @__PURE__ */ __name(async (out
2277
1501
  };
2278
1502
  return response;
2279
1503
  }, "de_DescribeFileSystemAssociationsCommand");
2280
- var de_DescribeFileSystemAssociationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2281
- const parsedOutput = {
2282
- ...output,
2283
- body: await parseErrorBody(output.body, context)
2284
- };
2285
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2286
- switch (errorCode) {
2287
- case "InternalServerError":
2288
- case "com.amazonaws.storagegateway#InternalServerError":
2289
- throw await de_InternalServerErrorRes(parsedOutput, context);
2290
- case "InvalidGatewayRequestException":
2291
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2292
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2293
- default:
2294
- const parsedBody = parsedOutput.body;
2295
- return throwDefaultError({
2296
- output,
2297
- parsedBody,
2298
- errorCode
2299
- });
2300
- }
2301
- }, "de_DescribeFileSystemAssociationsCommandError");
2302
1504
  var de_DescribeGatewayInformationCommand = /* @__PURE__ */ __name(async (output, context) => {
2303
1505
  if (output.statusCode >= 300) {
2304
- return de_DescribeGatewayInformationCommandError(output, context);
1506
+ return de_CommandError(output, context);
2305
1507
  }
2306
1508
  const data = await parseBody(output.body, context);
2307
1509
  let contents = {};
@@ -2312,31 +1514,9 @@ var de_DescribeGatewayInformationCommand = /* @__PURE__ */ __name(async (output,
2312
1514
  };
2313
1515
  return response;
2314
1516
  }, "de_DescribeGatewayInformationCommand");
2315
- var de_DescribeGatewayInformationCommandError = /* @__PURE__ */ __name(async (output, context) => {
2316
- const parsedOutput = {
2317
- ...output,
2318
- body: await parseErrorBody(output.body, context)
2319
- };
2320
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2321
- switch (errorCode) {
2322
- case "InternalServerError":
2323
- case "com.amazonaws.storagegateway#InternalServerError":
2324
- throw await de_InternalServerErrorRes(parsedOutput, context);
2325
- case "InvalidGatewayRequestException":
2326
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2327
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2328
- default:
2329
- const parsedBody = parsedOutput.body;
2330
- return throwDefaultError({
2331
- output,
2332
- parsedBody,
2333
- errorCode
2334
- });
2335
- }
2336
- }, "de_DescribeGatewayInformationCommandError");
2337
1517
  var de_DescribeMaintenanceStartTimeCommand = /* @__PURE__ */ __name(async (output, context) => {
2338
1518
  if (output.statusCode >= 300) {
2339
- return de_DescribeMaintenanceStartTimeCommandError(output, context);
1519
+ return de_CommandError(output, context);
2340
1520
  }
2341
1521
  const data = await parseBody(output.body, context);
2342
1522
  let contents = {};
@@ -2347,31 +1527,9 @@ var de_DescribeMaintenanceStartTimeCommand = /* @__PURE__ */ __name(async (outpu
2347
1527
  };
2348
1528
  return response;
2349
1529
  }, "de_DescribeMaintenanceStartTimeCommand");
2350
- var de_DescribeMaintenanceStartTimeCommandError = /* @__PURE__ */ __name(async (output, context) => {
2351
- const parsedOutput = {
2352
- ...output,
2353
- body: await parseErrorBody(output.body, context)
2354
- };
2355
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2356
- switch (errorCode) {
2357
- case "InternalServerError":
2358
- case "com.amazonaws.storagegateway#InternalServerError":
2359
- throw await de_InternalServerErrorRes(parsedOutput, context);
2360
- case "InvalidGatewayRequestException":
2361
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2362
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2363
- default:
2364
- const parsedBody = parsedOutput.body;
2365
- return throwDefaultError({
2366
- output,
2367
- parsedBody,
2368
- errorCode
2369
- });
2370
- }
2371
- }, "de_DescribeMaintenanceStartTimeCommandError");
2372
1530
  var de_DescribeNFSFileSharesCommand = /* @__PURE__ */ __name(async (output, context) => {
2373
1531
  if (output.statusCode >= 300) {
2374
- return de_DescribeNFSFileSharesCommandError(output, context);
1532
+ return de_CommandError(output, context);
2375
1533
  }
2376
1534
  const data = await parseBody(output.body, context);
2377
1535
  let contents = {};
@@ -2382,31 +1540,9 @@ var de_DescribeNFSFileSharesCommand = /* @__PURE__ */ __name(async (output, cont
2382
1540
  };
2383
1541
  return response;
2384
1542
  }, "de_DescribeNFSFileSharesCommand");
2385
- var de_DescribeNFSFileSharesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2386
- const parsedOutput = {
2387
- ...output,
2388
- body: await parseErrorBody(output.body, context)
2389
- };
2390
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2391
- switch (errorCode) {
2392
- case "InternalServerError":
2393
- case "com.amazonaws.storagegateway#InternalServerError":
2394
- throw await de_InternalServerErrorRes(parsedOutput, context);
2395
- case "InvalidGatewayRequestException":
2396
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2397
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2398
- default:
2399
- const parsedBody = parsedOutput.body;
2400
- return throwDefaultError({
2401
- output,
2402
- parsedBody,
2403
- errorCode
2404
- });
2405
- }
2406
- }, "de_DescribeNFSFileSharesCommandError");
2407
1543
  var de_DescribeSMBFileSharesCommand = /* @__PURE__ */ __name(async (output, context) => {
2408
1544
  if (output.statusCode >= 300) {
2409
- return de_DescribeSMBFileSharesCommandError(output, context);
1545
+ return de_CommandError(output, context);
2410
1546
  }
2411
1547
  const data = await parseBody(output.body, context);
2412
1548
  let contents = {};
@@ -2417,31 +1553,9 @@ var de_DescribeSMBFileSharesCommand = /* @__PURE__ */ __name(async (output, cont
2417
1553
  };
2418
1554
  return response;
2419
1555
  }, "de_DescribeSMBFileSharesCommand");
2420
- var de_DescribeSMBFileSharesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2421
- const parsedOutput = {
2422
- ...output,
2423
- body: await parseErrorBody(output.body, context)
2424
- };
2425
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2426
- switch (errorCode) {
2427
- case "InternalServerError":
2428
- case "com.amazonaws.storagegateway#InternalServerError":
2429
- throw await de_InternalServerErrorRes(parsedOutput, context);
2430
- case "InvalidGatewayRequestException":
2431
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2432
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2433
- default:
2434
- const parsedBody = parsedOutput.body;
2435
- return throwDefaultError({
2436
- output,
2437
- parsedBody,
2438
- errorCode
2439
- });
2440
- }
2441
- }, "de_DescribeSMBFileSharesCommandError");
2442
1556
  var de_DescribeSMBSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
2443
1557
  if (output.statusCode >= 300) {
2444
- return de_DescribeSMBSettingsCommandError(output, context);
1558
+ return de_CommandError(output, context);
2445
1559
  }
2446
1560
  const data = await parseBody(output.body, context);
2447
1561
  let contents = {};
@@ -2452,31 +1566,9 @@ var de_DescribeSMBSettingsCommand = /* @__PURE__ */ __name(async (output, contex
2452
1566
  };
2453
1567
  return response;
2454
1568
  }, "de_DescribeSMBSettingsCommand");
2455
- var de_DescribeSMBSettingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2456
- const parsedOutput = {
2457
- ...output,
2458
- body: await parseErrorBody(output.body, context)
2459
- };
2460
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2461
- switch (errorCode) {
2462
- case "InternalServerError":
2463
- case "com.amazonaws.storagegateway#InternalServerError":
2464
- throw await de_InternalServerErrorRes(parsedOutput, context);
2465
- case "InvalidGatewayRequestException":
2466
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2467
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2468
- default:
2469
- const parsedBody = parsedOutput.body;
2470
- return throwDefaultError({
2471
- output,
2472
- parsedBody,
2473
- errorCode
2474
- });
2475
- }
2476
- }, "de_DescribeSMBSettingsCommandError");
2477
1569
  var de_DescribeSnapshotScheduleCommand = /* @__PURE__ */ __name(async (output, context) => {
2478
1570
  if (output.statusCode >= 300) {
2479
- return de_DescribeSnapshotScheduleCommandError(output, context);
1571
+ return de_CommandError(output, context);
2480
1572
  }
2481
1573
  const data = await parseBody(output.body, context);
2482
1574
  let contents = {};
@@ -2487,31 +1579,9 @@ var de_DescribeSnapshotScheduleCommand = /* @__PURE__ */ __name(async (output, c
2487
1579
  };
2488
1580
  return response;
2489
1581
  }, "de_DescribeSnapshotScheduleCommand");
2490
- var de_DescribeSnapshotScheduleCommandError = /* @__PURE__ */ __name(async (output, context) => {
2491
- const parsedOutput = {
2492
- ...output,
2493
- body: await parseErrorBody(output.body, context)
2494
- };
2495
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2496
- switch (errorCode) {
2497
- case "InternalServerError":
2498
- case "com.amazonaws.storagegateway#InternalServerError":
2499
- throw await de_InternalServerErrorRes(parsedOutput, context);
2500
- case "InvalidGatewayRequestException":
2501
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2502
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2503
- default:
2504
- const parsedBody = parsedOutput.body;
2505
- return throwDefaultError({
2506
- output,
2507
- parsedBody,
2508
- errorCode
2509
- });
2510
- }
2511
- }, "de_DescribeSnapshotScheduleCommandError");
2512
1582
  var de_DescribeStorediSCSIVolumesCommand = /* @__PURE__ */ __name(async (output, context) => {
2513
1583
  if (output.statusCode >= 300) {
2514
- return de_DescribeStorediSCSIVolumesCommandError(output, context);
1584
+ return de_CommandError(output, context);
2515
1585
  }
2516
1586
  const data = await parseBody(output.body, context);
2517
1587
  let contents = {};
@@ -2522,31 +1592,9 @@ var de_DescribeStorediSCSIVolumesCommand = /* @__PURE__ */ __name(async (output,
2522
1592
  };
2523
1593
  return response;
2524
1594
  }, "de_DescribeStorediSCSIVolumesCommand");
2525
- var de_DescribeStorediSCSIVolumesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2526
- const parsedOutput = {
2527
- ...output,
2528
- body: await parseErrorBody(output.body, context)
2529
- };
2530
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2531
- switch (errorCode) {
2532
- case "InternalServerError":
2533
- case "com.amazonaws.storagegateway#InternalServerError":
2534
- throw await de_InternalServerErrorRes(parsedOutput, context);
2535
- case "InvalidGatewayRequestException":
2536
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2537
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2538
- default:
2539
- const parsedBody = parsedOutput.body;
2540
- return throwDefaultError({
2541
- output,
2542
- parsedBody,
2543
- errorCode
2544
- });
2545
- }
2546
- }, "de_DescribeStorediSCSIVolumesCommandError");
2547
1595
  var de_DescribeTapeArchivesCommand = /* @__PURE__ */ __name(async (output, context) => {
2548
1596
  if (output.statusCode >= 300) {
2549
- return de_DescribeTapeArchivesCommandError(output, context);
1597
+ return de_CommandError(output, context);
2550
1598
  }
2551
1599
  const data = await parseBody(output.body, context);
2552
1600
  let contents = {};
@@ -2557,31 +1605,9 @@ var de_DescribeTapeArchivesCommand = /* @__PURE__ */ __name(async (output, conte
2557
1605
  };
2558
1606
  return response;
2559
1607
  }, "de_DescribeTapeArchivesCommand");
2560
- var de_DescribeTapeArchivesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2561
- const parsedOutput = {
2562
- ...output,
2563
- body: await parseErrorBody(output.body, context)
2564
- };
2565
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2566
- switch (errorCode) {
2567
- case "InternalServerError":
2568
- case "com.amazonaws.storagegateway#InternalServerError":
2569
- throw await de_InternalServerErrorRes(parsedOutput, context);
2570
- case "InvalidGatewayRequestException":
2571
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2572
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2573
- default:
2574
- const parsedBody = parsedOutput.body;
2575
- return throwDefaultError({
2576
- output,
2577
- parsedBody,
2578
- errorCode
2579
- });
2580
- }
2581
- }, "de_DescribeTapeArchivesCommandError");
2582
1608
  var de_DescribeTapeRecoveryPointsCommand = /* @__PURE__ */ __name(async (output, context) => {
2583
1609
  if (output.statusCode >= 300) {
2584
- return de_DescribeTapeRecoveryPointsCommandError(output, context);
1610
+ return de_CommandError(output, context);
2585
1611
  }
2586
1612
  const data = await parseBody(output.body, context);
2587
1613
  let contents = {};
@@ -2592,31 +1618,9 @@ var de_DescribeTapeRecoveryPointsCommand = /* @__PURE__ */ __name(async (output,
2592
1618
  };
2593
1619
  return response;
2594
1620
  }, "de_DescribeTapeRecoveryPointsCommand");
2595
- var de_DescribeTapeRecoveryPointsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2596
- const parsedOutput = {
2597
- ...output,
2598
- body: await parseErrorBody(output.body, context)
2599
- };
2600
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2601
- switch (errorCode) {
2602
- case "InternalServerError":
2603
- case "com.amazonaws.storagegateway#InternalServerError":
2604
- throw await de_InternalServerErrorRes(parsedOutput, context);
2605
- case "InvalidGatewayRequestException":
2606
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2607
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2608
- default:
2609
- const parsedBody = parsedOutput.body;
2610
- return throwDefaultError({
2611
- output,
2612
- parsedBody,
2613
- errorCode
2614
- });
2615
- }
2616
- }, "de_DescribeTapeRecoveryPointsCommandError");
2617
1621
  var de_DescribeTapesCommand = /* @__PURE__ */ __name(async (output, context) => {
2618
1622
  if (output.statusCode >= 300) {
2619
- return de_DescribeTapesCommandError(output, context);
1623
+ return de_CommandError(output, context);
2620
1624
  }
2621
1625
  const data = await parseBody(output.body, context);
2622
1626
  let contents = {};
@@ -2627,31 +1631,9 @@ var de_DescribeTapesCommand = /* @__PURE__ */ __name(async (output, context) =>
2627
1631
  };
2628
1632
  return response;
2629
1633
  }, "de_DescribeTapesCommand");
2630
- var de_DescribeTapesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2631
- const parsedOutput = {
2632
- ...output,
2633
- body: await parseErrorBody(output.body, context)
2634
- };
2635
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2636
- switch (errorCode) {
2637
- case "InternalServerError":
2638
- case "com.amazonaws.storagegateway#InternalServerError":
2639
- throw await de_InternalServerErrorRes(parsedOutput, context);
2640
- case "InvalidGatewayRequestException":
2641
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2642
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2643
- default:
2644
- const parsedBody = parsedOutput.body;
2645
- return throwDefaultError({
2646
- output,
2647
- parsedBody,
2648
- errorCode
2649
- });
2650
- }
2651
- }, "de_DescribeTapesCommandError");
2652
1634
  var de_DescribeUploadBufferCommand = /* @__PURE__ */ __name(async (output, context) => {
2653
1635
  if (output.statusCode >= 300) {
2654
- return de_DescribeUploadBufferCommandError(output, context);
1636
+ return de_CommandError(output, context);
2655
1637
  }
2656
1638
  const data = await parseBody(output.body, context);
2657
1639
  let contents = {};
@@ -2662,31 +1644,9 @@ var de_DescribeUploadBufferCommand = /* @__PURE__ */ __name(async (output, conte
2662
1644
  };
2663
1645
  return response;
2664
1646
  }, "de_DescribeUploadBufferCommand");
2665
- var de_DescribeUploadBufferCommandError = /* @__PURE__ */ __name(async (output, context) => {
2666
- const parsedOutput = {
2667
- ...output,
2668
- body: await parseErrorBody(output.body, context)
2669
- };
2670
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2671
- switch (errorCode) {
2672
- case "InternalServerError":
2673
- case "com.amazonaws.storagegateway#InternalServerError":
2674
- throw await de_InternalServerErrorRes(parsedOutput, context);
2675
- case "InvalidGatewayRequestException":
2676
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2677
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2678
- default:
2679
- const parsedBody = parsedOutput.body;
2680
- return throwDefaultError({
2681
- output,
2682
- parsedBody,
2683
- errorCode
2684
- });
2685
- }
2686
- }, "de_DescribeUploadBufferCommandError");
2687
1647
  var de_DescribeVTLDevicesCommand = /* @__PURE__ */ __name(async (output, context) => {
2688
1648
  if (output.statusCode >= 300) {
2689
- return de_DescribeVTLDevicesCommandError(output, context);
1649
+ return de_CommandError(output, context);
2690
1650
  }
2691
1651
  const data = await parseBody(output.body, context);
2692
1652
  let contents = {};
@@ -2697,31 +1657,9 @@ var de_DescribeVTLDevicesCommand = /* @__PURE__ */ __name(async (output, context
2697
1657
  };
2698
1658
  return response;
2699
1659
  }, "de_DescribeVTLDevicesCommand");
2700
- var de_DescribeVTLDevicesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2701
- const parsedOutput = {
2702
- ...output,
2703
- body: await parseErrorBody(output.body, context)
2704
- };
2705
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2706
- switch (errorCode) {
2707
- case "InternalServerError":
2708
- case "com.amazonaws.storagegateway#InternalServerError":
2709
- throw await de_InternalServerErrorRes(parsedOutput, context);
2710
- case "InvalidGatewayRequestException":
2711
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2712
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2713
- default:
2714
- const parsedBody = parsedOutput.body;
2715
- return throwDefaultError({
2716
- output,
2717
- parsedBody,
2718
- errorCode
2719
- });
2720
- }
2721
- }, "de_DescribeVTLDevicesCommandError");
2722
1660
  var de_DescribeWorkingStorageCommand = /* @__PURE__ */ __name(async (output, context) => {
2723
1661
  if (output.statusCode >= 300) {
2724
- return de_DescribeWorkingStorageCommandError(output, context);
1662
+ return de_CommandError(output, context);
2725
1663
  }
2726
1664
  const data = await parseBody(output.body, context);
2727
1665
  let contents = {};
@@ -2732,31 +1670,9 @@ var de_DescribeWorkingStorageCommand = /* @__PURE__ */ __name(async (output, con
2732
1670
  };
2733
1671
  return response;
2734
1672
  }, "de_DescribeWorkingStorageCommand");
2735
- var de_DescribeWorkingStorageCommandError = /* @__PURE__ */ __name(async (output, context) => {
2736
- const parsedOutput = {
2737
- ...output,
2738
- body: await parseErrorBody(output.body, context)
2739
- };
2740
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2741
- switch (errorCode) {
2742
- case "InternalServerError":
2743
- case "com.amazonaws.storagegateway#InternalServerError":
2744
- throw await de_InternalServerErrorRes(parsedOutput, context);
2745
- case "InvalidGatewayRequestException":
2746
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2747
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2748
- default:
2749
- const parsedBody = parsedOutput.body;
2750
- return throwDefaultError({
2751
- output,
2752
- parsedBody,
2753
- errorCode
2754
- });
2755
- }
2756
- }, "de_DescribeWorkingStorageCommandError");
2757
1673
  var de_DetachVolumeCommand = /* @__PURE__ */ __name(async (output, context) => {
2758
1674
  if (output.statusCode >= 300) {
2759
- return de_DetachVolumeCommandError(output, context);
1675
+ return de_CommandError(output, context);
2760
1676
  }
2761
1677
  const data = await parseBody(output.body, context);
2762
1678
  let contents = {};
@@ -2767,31 +1683,9 @@ var de_DetachVolumeCommand = /* @__PURE__ */ __name(async (output, context) => {
2767
1683
  };
2768
1684
  return response;
2769
1685
  }, "de_DetachVolumeCommand");
2770
- var de_DetachVolumeCommandError = /* @__PURE__ */ __name(async (output, context) => {
2771
- const parsedOutput = {
2772
- ...output,
2773
- body: await parseErrorBody(output.body, context)
2774
- };
2775
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2776
- switch (errorCode) {
2777
- case "InternalServerError":
2778
- case "com.amazonaws.storagegateway#InternalServerError":
2779
- throw await de_InternalServerErrorRes(parsedOutput, context);
2780
- case "InvalidGatewayRequestException":
2781
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2782
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2783
- default:
2784
- const parsedBody = parsedOutput.body;
2785
- return throwDefaultError({
2786
- output,
2787
- parsedBody,
2788
- errorCode
2789
- });
2790
- }
2791
- }, "de_DetachVolumeCommandError");
2792
1686
  var de_DisableGatewayCommand = /* @__PURE__ */ __name(async (output, context) => {
2793
1687
  if (output.statusCode >= 300) {
2794
- return de_DisableGatewayCommandError(output, context);
1688
+ return de_CommandError(output, context);
2795
1689
  }
2796
1690
  const data = await parseBody(output.body, context);
2797
1691
  let contents = {};
@@ -2802,31 +1696,9 @@ var de_DisableGatewayCommand = /* @__PURE__ */ __name(async (output, context) =>
2802
1696
  };
2803
1697
  return response;
2804
1698
  }, "de_DisableGatewayCommand");
2805
- var de_DisableGatewayCommandError = /* @__PURE__ */ __name(async (output, context) => {
2806
- const parsedOutput = {
2807
- ...output,
2808
- body: await parseErrorBody(output.body, context)
2809
- };
2810
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2811
- switch (errorCode) {
2812
- case "InternalServerError":
2813
- case "com.amazonaws.storagegateway#InternalServerError":
2814
- throw await de_InternalServerErrorRes(parsedOutput, context);
2815
- case "InvalidGatewayRequestException":
2816
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2817
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2818
- default:
2819
- const parsedBody = parsedOutput.body;
2820
- return throwDefaultError({
2821
- output,
2822
- parsedBody,
2823
- errorCode
2824
- });
2825
- }
2826
- }, "de_DisableGatewayCommandError");
2827
1699
  var de_DisassociateFileSystemCommand = /* @__PURE__ */ __name(async (output, context) => {
2828
1700
  if (output.statusCode >= 300) {
2829
- return de_DisassociateFileSystemCommandError(output, context);
1701
+ return de_CommandError(output, context);
2830
1702
  }
2831
1703
  const data = await parseBody(output.body, context);
2832
1704
  let contents = {};
@@ -2837,31 +1709,9 @@ var de_DisassociateFileSystemCommand = /* @__PURE__ */ __name(async (output, con
2837
1709
  };
2838
1710
  return response;
2839
1711
  }, "de_DisassociateFileSystemCommand");
2840
- var de_DisassociateFileSystemCommandError = /* @__PURE__ */ __name(async (output, context) => {
2841
- const parsedOutput = {
2842
- ...output,
2843
- body: await parseErrorBody(output.body, context)
2844
- };
2845
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2846
- switch (errorCode) {
2847
- case "InternalServerError":
2848
- case "com.amazonaws.storagegateway#InternalServerError":
2849
- throw await de_InternalServerErrorRes(parsedOutput, context);
2850
- case "InvalidGatewayRequestException":
2851
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2852
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2853
- default:
2854
- const parsedBody = parsedOutput.body;
2855
- return throwDefaultError({
2856
- output,
2857
- parsedBody,
2858
- errorCode
2859
- });
2860
- }
2861
- }, "de_DisassociateFileSystemCommandError");
2862
1712
  var de_JoinDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
2863
1713
  if (output.statusCode >= 300) {
2864
- return de_JoinDomainCommandError(output, context);
1714
+ return de_CommandError(output, context);
2865
1715
  }
2866
1716
  const data = await parseBody(output.body, context);
2867
1717
  let contents = {};
@@ -2872,31 +1722,9 @@ var de_JoinDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
2872
1722
  };
2873
1723
  return response;
2874
1724
  }, "de_JoinDomainCommand");
2875
- var de_JoinDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
2876
- const parsedOutput = {
2877
- ...output,
2878
- body: await parseErrorBody(output.body, context)
2879
- };
2880
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2881
- switch (errorCode) {
2882
- case "InternalServerError":
2883
- case "com.amazonaws.storagegateway#InternalServerError":
2884
- throw await de_InternalServerErrorRes(parsedOutput, context);
2885
- case "InvalidGatewayRequestException":
2886
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2887
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2888
- default:
2889
- const parsedBody = parsedOutput.body;
2890
- return throwDefaultError({
2891
- output,
2892
- parsedBody,
2893
- errorCode
2894
- });
2895
- }
2896
- }, "de_JoinDomainCommandError");
2897
1725
  var de_ListAutomaticTapeCreationPoliciesCommand = /* @__PURE__ */ __name(async (output, context) => {
2898
1726
  if (output.statusCode >= 300) {
2899
- return de_ListAutomaticTapeCreationPoliciesCommandError(output, context);
1727
+ return de_CommandError(output, context);
2900
1728
  }
2901
1729
  const data = await parseBody(output.body, context);
2902
1730
  let contents = {};
@@ -2907,31 +1735,9 @@ var de_ListAutomaticTapeCreationPoliciesCommand = /* @__PURE__ */ __name(async (
2907
1735
  };
2908
1736
  return response;
2909
1737
  }, "de_ListAutomaticTapeCreationPoliciesCommand");
2910
- var de_ListAutomaticTapeCreationPoliciesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2911
- const parsedOutput = {
2912
- ...output,
2913
- body: await parseErrorBody(output.body, context)
2914
- };
2915
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2916
- switch (errorCode) {
2917
- case "InternalServerError":
2918
- case "com.amazonaws.storagegateway#InternalServerError":
2919
- throw await de_InternalServerErrorRes(parsedOutput, context);
2920
- case "InvalidGatewayRequestException":
2921
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2922
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2923
- default:
2924
- const parsedBody = parsedOutput.body;
2925
- return throwDefaultError({
2926
- output,
2927
- parsedBody,
2928
- errorCode
2929
- });
2930
- }
2931
- }, "de_ListAutomaticTapeCreationPoliciesCommandError");
2932
1738
  var de_ListFileSharesCommand = /* @__PURE__ */ __name(async (output, context) => {
2933
1739
  if (output.statusCode >= 300) {
2934
- return de_ListFileSharesCommandError(output, context);
1740
+ return de_CommandError(output, context);
2935
1741
  }
2936
1742
  const data = await parseBody(output.body, context);
2937
1743
  let contents = {};
@@ -2942,31 +1748,9 @@ var de_ListFileSharesCommand = /* @__PURE__ */ __name(async (output, context) =>
2942
1748
  };
2943
1749
  return response;
2944
1750
  }, "de_ListFileSharesCommand");
2945
- var de_ListFileSharesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2946
- const parsedOutput = {
2947
- ...output,
2948
- body: await parseErrorBody(output.body, context)
2949
- };
2950
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2951
- switch (errorCode) {
2952
- case "InternalServerError":
2953
- case "com.amazonaws.storagegateway#InternalServerError":
2954
- throw await de_InternalServerErrorRes(parsedOutput, context);
2955
- case "InvalidGatewayRequestException":
2956
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2957
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2958
- default:
2959
- const parsedBody = parsedOutput.body;
2960
- return throwDefaultError({
2961
- output,
2962
- parsedBody,
2963
- errorCode
2964
- });
2965
- }
2966
- }, "de_ListFileSharesCommandError");
2967
1751
  var de_ListFileSystemAssociationsCommand = /* @__PURE__ */ __name(async (output, context) => {
2968
1752
  if (output.statusCode >= 300) {
2969
- return de_ListFileSystemAssociationsCommandError(output, context);
1753
+ return de_CommandError(output, context);
2970
1754
  }
2971
1755
  const data = await parseBody(output.body, context);
2972
1756
  let contents = {};
@@ -2977,31 +1761,9 @@ var de_ListFileSystemAssociationsCommand = /* @__PURE__ */ __name(async (output,
2977
1761
  };
2978
1762
  return response;
2979
1763
  }, "de_ListFileSystemAssociationsCommand");
2980
- var de_ListFileSystemAssociationsCommandError = /* @__PURE__ */ __name(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 "InternalServerError":
2988
- case "com.amazonaws.storagegateway#InternalServerError":
2989
- throw await de_InternalServerErrorRes(parsedOutput, context);
2990
- case "InvalidGatewayRequestException":
2991
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
2992
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2993
- default:
2994
- const parsedBody = parsedOutput.body;
2995
- return throwDefaultError({
2996
- output,
2997
- parsedBody,
2998
- errorCode
2999
- });
3000
- }
3001
- }, "de_ListFileSystemAssociationsCommandError");
3002
1764
  var de_ListGatewaysCommand = /* @__PURE__ */ __name(async (output, context) => {
3003
1765
  if (output.statusCode >= 300) {
3004
- return de_ListGatewaysCommandError(output, context);
1766
+ return de_CommandError(output, context);
3005
1767
  }
3006
1768
  const data = await parseBody(output.body, context);
3007
1769
  let contents = {};
@@ -3012,31 +1774,9 @@ var de_ListGatewaysCommand = /* @__PURE__ */ __name(async (output, context) => {
3012
1774
  };
3013
1775
  return response;
3014
1776
  }, "de_ListGatewaysCommand");
3015
- var de_ListGatewaysCommandError = /* @__PURE__ */ __name(async (output, context) => {
3016
- const parsedOutput = {
3017
- ...output,
3018
- body: await parseErrorBody(output.body, context)
3019
- };
3020
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3021
- switch (errorCode) {
3022
- case "InternalServerError":
3023
- case "com.amazonaws.storagegateway#InternalServerError":
3024
- throw await de_InternalServerErrorRes(parsedOutput, context);
3025
- case "InvalidGatewayRequestException":
3026
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3027
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3028
- default:
3029
- const parsedBody = parsedOutput.body;
3030
- return throwDefaultError({
3031
- output,
3032
- parsedBody,
3033
- errorCode
3034
- });
3035
- }
3036
- }, "de_ListGatewaysCommandError");
3037
1777
  var de_ListLocalDisksCommand = /* @__PURE__ */ __name(async (output, context) => {
3038
1778
  if (output.statusCode >= 300) {
3039
- return de_ListLocalDisksCommandError(output, context);
1779
+ return de_CommandError(output, context);
3040
1780
  }
3041
1781
  const data = await parseBody(output.body, context);
3042
1782
  let contents = {};
@@ -3047,31 +1787,9 @@ var de_ListLocalDisksCommand = /* @__PURE__ */ __name(async (output, context) =>
3047
1787
  };
3048
1788
  return response;
3049
1789
  }, "de_ListLocalDisksCommand");
3050
- var de_ListLocalDisksCommandError = /* @__PURE__ */ __name(async (output, context) => {
3051
- const parsedOutput = {
3052
- ...output,
3053
- body: await parseErrorBody(output.body, context)
3054
- };
3055
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3056
- switch (errorCode) {
3057
- case "InternalServerError":
3058
- case "com.amazonaws.storagegateway#InternalServerError":
3059
- throw await de_InternalServerErrorRes(parsedOutput, context);
3060
- case "InvalidGatewayRequestException":
3061
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3062
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3063
- default:
3064
- const parsedBody = parsedOutput.body;
3065
- return throwDefaultError({
3066
- output,
3067
- parsedBody,
3068
- errorCode
3069
- });
3070
- }
3071
- }, "de_ListLocalDisksCommandError");
3072
1790
  var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
3073
1791
  if (output.statusCode >= 300) {
3074
- return de_ListTagsForResourceCommandError(output, context);
1792
+ return de_CommandError(output, context);
3075
1793
  }
3076
1794
  const data = await parseBody(output.body, context);
3077
1795
  let contents = {};
@@ -3082,31 +1800,9 @@ var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, contex
3082
1800
  };
3083
1801
  return response;
3084
1802
  }, "de_ListTagsForResourceCommand");
3085
- var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
3086
- const parsedOutput = {
3087
- ...output,
3088
- body: await parseErrorBody(output.body, context)
3089
- };
3090
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3091
- switch (errorCode) {
3092
- case "InternalServerError":
3093
- case "com.amazonaws.storagegateway#InternalServerError":
3094
- throw await de_InternalServerErrorRes(parsedOutput, context);
3095
- case "InvalidGatewayRequestException":
3096
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3097
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3098
- default:
3099
- const parsedBody = parsedOutput.body;
3100
- return throwDefaultError({
3101
- output,
3102
- parsedBody,
3103
- errorCode
3104
- });
3105
- }
3106
- }, "de_ListTagsForResourceCommandError");
3107
1803
  var de_ListTapePoolsCommand = /* @__PURE__ */ __name(async (output, context) => {
3108
1804
  if (output.statusCode >= 300) {
3109
- return de_ListTapePoolsCommandError(output, context);
1805
+ return de_CommandError(output, context);
3110
1806
  }
3111
1807
  const data = await parseBody(output.body, context);
3112
1808
  let contents = {};
@@ -3117,31 +1813,9 @@ var de_ListTapePoolsCommand = /* @__PURE__ */ __name(async (output, context) =>
3117
1813
  };
3118
1814
  return response;
3119
1815
  }, "de_ListTapePoolsCommand");
3120
- var de_ListTapePoolsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3121
- const parsedOutput = {
3122
- ...output,
3123
- body: await parseErrorBody(output.body, context)
3124
- };
3125
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3126
- switch (errorCode) {
3127
- case "InternalServerError":
3128
- case "com.amazonaws.storagegateway#InternalServerError":
3129
- throw await de_InternalServerErrorRes(parsedOutput, context);
3130
- case "InvalidGatewayRequestException":
3131
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3132
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3133
- default:
3134
- const parsedBody = parsedOutput.body;
3135
- return throwDefaultError({
3136
- output,
3137
- parsedBody,
3138
- errorCode
3139
- });
3140
- }
3141
- }, "de_ListTapePoolsCommandError");
3142
1816
  var de_ListTapesCommand = /* @__PURE__ */ __name(async (output, context) => {
3143
1817
  if (output.statusCode >= 300) {
3144
- return de_ListTapesCommandError(output, context);
1818
+ return de_CommandError(output, context);
3145
1819
  }
3146
1820
  const data = await parseBody(output.body, context);
3147
1821
  let contents = {};
@@ -3152,31 +1826,9 @@ var de_ListTapesCommand = /* @__PURE__ */ __name(async (output, context) => {
3152
1826
  };
3153
1827
  return response;
3154
1828
  }, "de_ListTapesCommand");
3155
- var de_ListTapesCommandError = /* @__PURE__ */ __name(async (output, context) => {
3156
- const parsedOutput = {
3157
- ...output,
3158
- body: await parseErrorBody(output.body, context)
3159
- };
3160
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3161
- switch (errorCode) {
3162
- case "InternalServerError":
3163
- case "com.amazonaws.storagegateway#InternalServerError":
3164
- throw await de_InternalServerErrorRes(parsedOutput, context);
3165
- case "InvalidGatewayRequestException":
3166
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3167
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3168
- default:
3169
- const parsedBody = parsedOutput.body;
3170
- return throwDefaultError({
3171
- output,
3172
- parsedBody,
3173
- errorCode
3174
- });
3175
- }
3176
- }, "de_ListTapesCommandError");
3177
1829
  var de_ListVolumeInitiatorsCommand = /* @__PURE__ */ __name(async (output, context) => {
3178
1830
  if (output.statusCode >= 300) {
3179
- return de_ListVolumeInitiatorsCommandError(output, context);
1831
+ return de_CommandError(output, context);
3180
1832
  }
3181
1833
  const data = await parseBody(output.body, context);
3182
1834
  let contents = {};
@@ -3187,31 +1839,9 @@ var de_ListVolumeInitiatorsCommand = /* @__PURE__ */ __name(async (output, conte
3187
1839
  };
3188
1840
  return response;
3189
1841
  }, "de_ListVolumeInitiatorsCommand");
3190
- var de_ListVolumeInitiatorsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3191
- const parsedOutput = {
3192
- ...output,
3193
- body: await parseErrorBody(output.body, context)
3194
- };
3195
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3196
- switch (errorCode) {
3197
- case "InternalServerError":
3198
- case "com.amazonaws.storagegateway#InternalServerError":
3199
- throw await de_InternalServerErrorRes(parsedOutput, context);
3200
- case "InvalidGatewayRequestException":
3201
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3202
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3203
- default:
3204
- const parsedBody = parsedOutput.body;
3205
- return throwDefaultError({
3206
- output,
3207
- parsedBody,
3208
- errorCode
3209
- });
3210
- }
3211
- }, "de_ListVolumeInitiatorsCommandError");
3212
1842
  var de_ListVolumeRecoveryPointsCommand = /* @__PURE__ */ __name(async (output, context) => {
3213
1843
  if (output.statusCode >= 300) {
3214
- return de_ListVolumeRecoveryPointsCommandError(output, context);
1844
+ return de_CommandError(output, context);
3215
1845
  }
3216
1846
  const data = await parseBody(output.body, context);
3217
1847
  let contents = {};
@@ -3222,66 +1852,22 @@ var de_ListVolumeRecoveryPointsCommand = /* @__PURE__ */ __name(async (output, c
3222
1852
  };
3223
1853
  return response;
3224
1854
  }, "de_ListVolumeRecoveryPointsCommand");
3225
- var de_ListVolumeRecoveryPointsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3226
- const parsedOutput = {
3227
- ...output,
3228
- body: await parseErrorBody(output.body, context)
3229
- };
3230
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3231
- switch (errorCode) {
3232
- case "InternalServerError":
3233
- case "com.amazonaws.storagegateway#InternalServerError":
3234
- throw await de_InternalServerErrorRes(parsedOutput, context);
3235
- case "InvalidGatewayRequestException":
3236
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3237
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3238
- default:
3239
- const parsedBody = parsedOutput.body;
3240
- return throwDefaultError({
3241
- output,
3242
- parsedBody,
3243
- errorCode
3244
- });
3245
- }
3246
- }, "de_ListVolumeRecoveryPointsCommandError");
3247
- var de_ListVolumesCommand = /* @__PURE__ */ __name(async (output, context) => {
3248
- if (output.statusCode >= 300) {
3249
- return de_ListVolumesCommandError(output, context);
3250
- }
3251
- const data = await parseBody(output.body, context);
3252
- let contents = {};
3253
- contents = (0, import_smithy_client._json)(data);
3254
- const response = {
3255
- $metadata: deserializeMetadata(output),
3256
- ...contents
1855
+ var de_ListVolumesCommand = /* @__PURE__ */ __name(async (output, context) => {
1856
+ if (output.statusCode >= 300) {
1857
+ return de_CommandError(output, context);
1858
+ }
1859
+ const data = await parseBody(output.body, context);
1860
+ let contents = {};
1861
+ contents = (0, import_smithy_client._json)(data);
1862
+ const response = {
1863
+ $metadata: deserializeMetadata(output),
1864
+ ...contents
3257
1865
  };
3258
1866
  return response;
3259
1867
  }, "de_ListVolumesCommand");
3260
- var de_ListVolumesCommandError = /* @__PURE__ */ __name(async (output, context) => {
3261
- const parsedOutput = {
3262
- ...output,
3263
- body: await parseErrorBody(output.body, context)
3264
- };
3265
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3266
- switch (errorCode) {
3267
- case "InternalServerError":
3268
- case "com.amazonaws.storagegateway#InternalServerError":
3269
- throw await de_InternalServerErrorRes(parsedOutput, context);
3270
- case "InvalidGatewayRequestException":
3271
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3272
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3273
- default:
3274
- const parsedBody = parsedOutput.body;
3275
- return throwDefaultError({
3276
- output,
3277
- parsedBody,
3278
- errorCode
3279
- });
3280
- }
3281
- }, "de_ListVolumesCommandError");
3282
1868
  var de_NotifyWhenUploadedCommand = /* @__PURE__ */ __name(async (output, context) => {
3283
1869
  if (output.statusCode >= 300) {
3284
- return de_NotifyWhenUploadedCommandError(output, context);
1870
+ return de_CommandError(output, context);
3285
1871
  }
3286
1872
  const data = await parseBody(output.body, context);
3287
1873
  let contents = {};
@@ -3292,31 +1878,9 @@ var de_NotifyWhenUploadedCommand = /* @__PURE__ */ __name(async (output, context
3292
1878
  };
3293
1879
  return response;
3294
1880
  }, "de_NotifyWhenUploadedCommand");
3295
- var de_NotifyWhenUploadedCommandError = /* @__PURE__ */ __name(async (output, context) => {
3296
- const parsedOutput = {
3297
- ...output,
3298
- body: await parseErrorBody(output.body, context)
3299
- };
3300
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3301
- switch (errorCode) {
3302
- case "InternalServerError":
3303
- case "com.amazonaws.storagegateway#InternalServerError":
3304
- throw await de_InternalServerErrorRes(parsedOutput, context);
3305
- case "InvalidGatewayRequestException":
3306
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3307
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3308
- default:
3309
- const parsedBody = parsedOutput.body;
3310
- return throwDefaultError({
3311
- output,
3312
- parsedBody,
3313
- errorCode
3314
- });
3315
- }
3316
- }, "de_NotifyWhenUploadedCommandError");
3317
1881
  var de_RefreshCacheCommand = /* @__PURE__ */ __name(async (output, context) => {
3318
1882
  if (output.statusCode >= 300) {
3319
- return de_RefreshCacheCommandError(output, context);
1883
+ return de_CommandError(output, context);
3320
1884
  }
3321
1885
  const data = await parseBody(output.body, context);
3322
1886
  let contents = {};
@@ -3327,31 +1891,9 @@ var de_RefreshCacheCommand = /* @__PURE__ */ __name(async (output, context) => {
3327
1891
  };
3328
1892
  return response;
3329
1893
  }, "de_RefreshCacheCommand");
3330
- var de_RefreshCacheCommandError = /* @__PURE__ */ __name(async (output, context) => {
3331
- const parsedOutput = {
3332
- ...output,
3333
- body: await parseErrorBody(output.body, context)
3334
- };
3335
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3336
- switch (errorCode) {
3337
- case "InternalServerError":
3338
- case "com.amazonaws.storagegateway#InternalServerError":
3339
- throw await de_InternalServerErrorRes(parsedOutput, context);
3340
- case "InvalidGatewayRequestException":
3341
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3342
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3343
- default:
3344
- const parsedBody = parsedOutput.body;
3345
- return throwDefaultError({
3346
- output,
3347
- parsedBody,
3348
- errorCode
3349
- });
3350
- }
3351
- }, "de_RefreshCacheCommandError");
3352
1894
  var de_RemoveTagsFromResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
3353
1895
  if (output.statusCode >= 300) {
3354
- return de_RemoveTagsFromResourceCommandError(output, context);
1896
+ return de_CommandError(output, context);
3355
1897
  }
3356
1898
  const data = await parseBody(output.body, context);
3357
1899
  let contents = {};
@@ -3362,31 +1904,9 @@ var de_RemoveTagsFromResourceCommand = /* @__PURE__ */ __name(async (output, con
3362
1904
  };
3363
1905
  return response;
3364
1906
  }, "de_RemoveTagsFromResourceCommand");
3365
- var de_RemoveTagsFromResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
3366
- const parsedOutput = {
3367
- ...output,
3368
- body: await parseErrorBody(output.body, context)
3369
- };
3370
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3371
- switch (errorCode) {
3372
- case "InternalServerError":
3373
- case "com.amazonaws.storagegateway#InternalServerError":
3374
- throw await de_InternalServerErrorRes(parsedOutput, context);
3375
- case "InvalidGatewayRequestException":
3376
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3377
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3378
- default:
3379
- const parsedBody = parsedOutput.body;
3380
- return throwDefaultError({
3381
- output,
3382
- parsedBody,
3383
- errorCode
3384
- });
3385
- }
3386
- }, "de_RemoveTagsFromResourceCommandError");
3387
1907
  var de_ResetCacheCommand = /* @__PURE__ */ __name(async (output, context) => {
3388
1908
  if (output.statusCode >= 300) {
3389
- return de_ResetCacheCommandError(output, context);
1909
+ return de_CommandError(output, context);
3390
1910
  }
3391
1911
  const data = await parseBody(output.body, context);
3392
1912
  let contents = {};
@@ -3397,31 +1917,9 @@ var de_ResetCacheCommand = /* @__PURE__ */ __name(async (output, context) => {
3397
1917
  };
3398
1918
  return response;
3399
1919
  }, "de_ResetCacheCommand");
3400
- var de_ResetCacheCommandError = /* @__PURE__ */ __name(async (output, context) => {
3401
- const parsedOutput = {
3402
- ...output,
3403
- body: await parseErrorBody(output.body, context)
3404
- };
3405
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3406
- switch (errorCode) {
3407
- case "InternalServerError":
3408
- case "com.amazonaws.storagegateway#InternalServerError":
3409
- throw await de_InternalServerErrorRes(parsedOutput, context);
3410
- case "InvalidGatewayRequestException":
3411
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3412
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3413
- default:
3414
- const parsedBody = parsedOutput.body;
3415
- return throwDefaultError({
3416
- output,
3417
- parsedBody,
3418
- errorCode
3419
- });
3420
- }
3421
- }, "de_ResetCacheCommandError");
3422
1920
  var de_RetrieveTapeArchiveCommand = /* @__PURE__ */ __name(async (output, context) => {
3423
1921
  if (output.statusCode >= 300) {
3424
- return de_RetrieveTapeArchiveCommandError(output, context);
1922
+ return de_CommandError(output, context);
3425
1923
  }
3426
1924
  const data = await parseBody(output.body, context);
3427
1925
  let contents = {};
@@ -3432,31 +1930,9 @@ var de_RetrieveTapeArchiveCommand = /* @__PURE__ */ __name(async (output, contex
3432
1930
  };
3433
1931
  return response;
3434
1932
  }, "de_RetrieveTapeArchiveCommand");
3435
- var de_RetrieveTapeArchiveCommandError = /* @__PURE__ */ __name(async (output, context) => {
3436
- const parsedOutput = {
3437
- ...output,
3438
- body: await parseErrorBody(output.body, context)
3439
- };
3440
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3441
- switch (errorCode) {
3442
- case "InternalServerError":
3443
- case "com.amazonaws.storagegateway#InternalServerError":
3444
- throw await de_InternalServerErrorRes(parsedOutput, context);
3445
- case "InvalidGatewayRequestException":
3446
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3447
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3448
- default:
3449
- const parsedBody = parsedOutput.body;
3450
- return throwDefaultError({
3451
- output,
3452
- parsedBody,
3453
- errorCode
3454
- });
3455
- }
3456
- }, "de_RetrieveTapeArchiveCommandError");
3457
1933
  var de_RetrieveTapeRecoveryPointCommand = /* @__PURE__ */ __name(async (output, context) => {
3458
1934
  if (output.statusCode >= 300) {
3459
- return de_RetrieveTapeRecoveryPointCommandError(output, context);
1935
+ return de_CommandError(output, context);
3460
1936
  }
3461
1937
  const data = await parseBody(output.body, context);
3462
1938
  let contents = {};
@@ -3467,31 +1943,9 @@ var de_RetrieveTapeRecoveryPointCommand = /* @__PURE__ */ __name(async (output,
3467
1943
  };
3468
1944
  return response;
3469
1945
  }, "de_RetrieveTapeRecoveryPointCommand");
3470
- var de_RetrieveTapeRecoveryPointCommandError = /* @__PURE__ */ __name(async (output, context) => {
3471
- const parsedOutput = {
3472
- ...output,
3473
- body: await parseErrorBody(output.body, context)
3474
- };
3475
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3476
- switch (errorCode) {
3477
- case "InternalServerError":
3478
- case "com.amazonaws.storagegateway#InternalServerError":
3479
- throw await de_InternalServerErrorRes(parsedOutput, context);
3480
- case "InvalidGatewayRequestException":
3481
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3482
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3483
- default:
3484
- const parsedBody = parsedOutput.body;
3485
- return throwDefaultError({
3486
- output,
3487
- parsedBody,
3488
- errorCode
3489
- });
3490
- }
3491
- }, "de_RetrieveTapeRecoveryPointCommandError");
3492
1946
  var de_SetLocalConsolePasswordCommand = /* @__PURE__ */ __name(async (output, context) => {
3493
1947
  if (output.statusCode >= 300) {
3494
- return de_SetLocalConsolePasswordCommandError(output, context);
1948
+ return de_CommandError(output, context);
3495
1949
  }
3496
1950
  const data = await parseBody(output.body, context);
3497
1951
  let contents = {};
@@ -3502,31 +1956,9 @@ var de_SetLocalConsolePasswordCommand = /* @__PURE__ */ __name(async (output, co
3502
1956
  };
3503
1957
  return response;
3504
1958
  }, "de_SetLocalConsolePasswordCommand");
3505
- var de_SetLocalConsolePasswordCommandError = /* @__PURE__ */ __name(async (output, context) => {
3506
- const parsedOutput = {
3507
- ...output,
3508
- body: await parseErrorBody(output.body, context)
3509
- };
3510
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3511
- switch (errorCode) {
3512
- case "InternalServerError":
3513
- case "com.amazonaws.storagegateway#InternalServerError":
3514
- throw await de_InternalServerErrorRes(parsedOutput, context);
3515
- case "InvalidGatewayRequestException":
3516
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3517
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3518
- default:
3519
- const parsedBody = parsedOutput.body;
3520
- return throwDefaultError({
3521
- output,
3522
- parsedBody,
3523
- errorCode
3524
- });
3525
- }
3526
- }, "de_SetLocalConsolePasswordCommandError");
3527
1959
  var de_SetSMBGuestPasswordCommand = /* @__PURE__ */ __name(async (output, context) => {
3528
1960
  if (output.statusCode >= 300) {
3529
- return de_SetSMBGuestPasswordCommandError(output, context);
1961
+ return de_CommandError(output, context);
3530
1962
  }
3531
1963
  const data = await parseBody(output.body, context);
3532
1964
  let contents = {};
@@ -3537,31 +1969,9 @@ var de_SetSMBGuestPasswordCommand = /* @__PURE__ */ __name(async (output, contex
3537
1969
  };
3538
1970
  return response;
3539
1971
  }, "de_SetSMBGuestPasswordCommand");
3540
- var de_SetSMBGuestPasswordCommandError = /* @__PURE__ */ __name(async (output, context) => {
3541
- const parsedOutput = {
3542
- ...output,
3543
- body: await parseErrorBody(output.body, context)
3544
- };
3545
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3546
- switch (errorCode) {
3547
- case "InternalServerError":
3548
- case "com.amazonaws.storagegateway#InternalServerError":
3549
- throw await de_InternalServerErrorRes(parsedOutput, context);
3550
- case "InvalidGatewayRequestException":
3551
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3552
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3553
- default:
3554
- const parsedBody = parsedOutput.body;
3555
- return throwDefaultError({
3556
- output,
3557
- parsedBody,
3558
- errorCode
3559
- });
3560
- }
3561
- }, "de_SetSMBGuestPasswordCommandError");
3562
1972
  var de_ShutdownGatewayCommand = /* @__PURE__ */ __name(async (output, context) => {
3563
1973
  if (output.statusCode >= 300) {
3564
- return de_ShutdownGatewayCommandError(output, context);
1974
+ return de_CommandError(output, context);
3565
1975
  }
3566
1976
  const data = await parseBody(output.body, context);
3567
1977
  let contents = {};
@@ -3572,31 +1982,9 @@ var de_ShutdownGatewayCommand = /* @__PURE__ */ __name(async (output, context) =
3572
1982
  };
3573
1983
  return response;
3574
1984
  }, "de_ShutdownGatewayCommand");
3575
- var de_ShutdownGatewayCommandError = /* @__PURE__ */ __name(async (output, context) => {
3576
- const parsedOutput = {
3577
- ...output,
3578
- body: await parseErrorBody(output.body, context)
3579
- };
3580
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3581
- switch (errorCode) {
3582
- case "InternalServerError":
3583
- case "com.amazonaws.storagegateway#InternalServerError":
3584
- throw await de_InternalServerErrorRes(parsedOutput, context);
3585
- case "InvalidGatewayRequestException":
3586
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3587
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3588
- default:
3589
- const parsedBody = parsedOutput.body;
3590
- return throwDefaultError({
3591
- output,
3592
- parsedBody,
3593
- errorCode
3594
- });
3595
- }
3596
- }, "de_ShutdownGatewayCommandError");
3597
1985
  var de_StartAvailabilityMonitorTestCommand = /* @__PURE__ */ __name(async (output, context) => {
3598
1986
  if (output.statusCode >= 300) {
3599
- return de_StartAvailabilityMonitorTestCommandError(output, context);
1987
+ return de_CommandError(output, context);
3600
1988
  }
3601
1989
  const data = await parseBody(output.body, context);
3602
1990
  let contents = {};
@@ -3607,31 +1995,9 @@ var de_StartAvailabilityMonitorTestCommand = /* @__PURE__ */ __name(async (outpu
3607
1995
  };
3608
1996
  return response;
3609
1997
  }, "de_StartAvailabilityMonitorTestCommand");
3610
- var de_StartAvailabilityMonitorTestCommandError = /* @__PURE__ */ __name(async (output, context) => {
3611
- const parsedOutput = {
3612
- ...output,
3613
- body: await parseErrorBody(output.body, context)
3614
- };
3615
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3616
- switch (errorCode) {
3617
- case "InternalServerError":
3618
- case "com.amazonaws.storagegateway#InternalServerError":
3619
- throw await de_InternalServerErrorRes(parsedOutput, context);
3620
- case "InvalidGatewayRequestException":
3621
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3622
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3623
- default:
3624
- const parsedBody = parsedOutput.body;
3625
- return throwDefaultError({
3626
- output,
3627
- parsedBody,
3628
- errorCode
3629
- });
3630
- }
3631
- }, "de_StartAvailabilityMonitorTestCommandError");
3632
1998
  var de_StartGatewayCommand = /* @__PURE__ */ __name(async (output, context) => {
3633
1999
  if (output.statusCode >= 300) {
3634
- return de_StartGatewayCommandError(output, context);
2000
+ return de_CommandError(output, context);
3635
2001
  }
3636
2002
  const data = await parseBody(output.body, context);
3637
2003
  let contents = {};
@@ -3642,66 +2008,9 @@ var de_StartGatewayCommand = /* @__PURE__ */ __name(async (output, context) => {
3642
2008
  };
3643
2009
  return response;
3644
2010
  }, "de_StartGatewayCommand");
3645
- var de_StartGatewayCommandError = /* @__PURE__ */ __name(async (output, context) => {
3646
- const parsedOutput = {
3647
- ...output,
3648
- body: await parseErrorBody(output.body, context)
3649
- };
3650
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3651
- switch (errorCode) {
3652
- case "InternalServerError":
3653
- case "com.amazonaws.storagegateway#InternalServerError":
3654
- throw await de_InternalServerErrorRes(parsedOutput, context);
3655
- case "InvalidGatewayRequestException":
3656
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3657
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3658
- default:
3659
- const parsedBody = parsedOutput.body;
3660
- return throwDefaultError({
3661
- output,
3662
- parsedBody,
3663
- errorCode
3664
- });
3665
- }
3666
- }, "de_StartGatewayCommandError");
3667
2011
  var de_UpdateAutomaticTapeCreationPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
3668
2012
  if (output.statusCode >= 300) {
3669
- return de_UpdateAutomaticTapeCreationPolicyCommandError(output, context);
3670
- }
3671
- const data = await parseBody(output.body, context);
3672
- let contents = {};
3673
- contents = (0, import_smithy_client._json)(data);
3674
- const response = {
3675
- $metadata: deserializeMetadata(output),
3676
- ...contents
3677
- };
3678
- return response;
3679
- }, "de_UpdateAutomaticTapeCreationPolicyCommand");
3680
- var de_UpdateAutomaticTapeCreationPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
3681
- const parsedOutput = {
3682
- ...output,
3683
- body: await parseErrorBody(output.body, context)
3684
- };
3685
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3686
- switch (errorCode) {
3687
- case "InternalServerError":
3688
- case "com.amazonaws.storagegateway#InternalServerError":
3689
- throw await de_InternalServerErrorRes(parsedOutput, context);
3690
- case "InvalidGatewayRequestException":
3691
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3692
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3693
- default:
3694
- const parsedBody = parsedOutput.body;
3695
- return throwDefaultError({
3696
- output,
3697
- parsedBody,
3698
- errorCode
3699
- });
3700
- }
3701
- }, "de_UpdateAutomaticTapeCreationPolicyCommandError");
3702
- var de_UpdateBandwidthRateLimitCommand = /* @__PURE__ */ __name(async (output, context) => {
3703
- if (output.statusCode >= 300) {
3704
- return de_UpdateBandwidthRateLimitCommandError(output, context);
2013
+ return de_CommandError(output, context);
3705
2014
  }
3706
2015
  const data = await parseBody(output.body, context);
3707
2016
  let contents = {};
@@ -3710,33 +2019,24 @@ var de_UpdateBandwidthRateLimitCommand = /* @__PURE__ */ __name(async (output, c
3710
2019
  $metadata: deserializeMetadata(output),
3711
2020
  ...contents
3712
2021
  };
3713
- return response;
3714
- }, "de_UpdateBandwidthRateLimitCommand");
3715
- var de_UpdateBandwidthRateLimitCommandError = /* @__PURE__ */ __name(async (output, context) => {
3716
- const parsedOutput = {
3717
- ...output,
3718
- body: await parseErrorBody(output.body, context)
3719
- };
3720
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3721
- switch (errorCode) {
3722
- case "InternalServerError":
3723
- case "com.amazonaws.storagegateway#InternalServerError":
3724
- throw await de_InternalServerErrorRes(parsedOutput, context);
3725
- case "InvalidGatewayRequestException":
3726
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3727
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3728
- default:
3729
- const parsedBody = parsedOutput.body;
3730
- return throwDefaultError({
3731
- output,
3732
- parsedBody,
3733
- errorCode
3734
- });
2022
+ return response;
2023
+ }, "de_UpdateAutomaticTapeCreationPolicyCommand");
2024
+ var de_UpdateBandwidthRateLimitCommand = /* @__PURE__ */ __name(async (output, context) => {
2025
+ if (output.statusCode >= 300) {
2026
+ return de_CommandError(output, context);
3735
2027
  }
3736
- }, "de_UpdateBandwidthRateLimitCommandError");
2028
+ const data = await parseBody(output.body, context);
2029
+ let contents = {};
2030
+ contents = (0, import_smithy_client._json)(data);
2031
+ const response = {
2032
+ $metadata: deserializeMetadata(output),
2033
+ ...contents
2034
+ };
2035
+ return response;
2036
+ }, "de_UpdateBandwidthRateLimitCommand");
3737
2037
  var de_UpdateBandwidthRateLimitScheduleCommand = /* @__PURE__ */ __name(async (output, context) => {
3738
2038
  if (output.statusCode >= 300) {
3739
- return de_UpdateBandwidthRateLimitScheduleCommandError(output, context);
2039
+ return de_CommandError(output, context);
3740
2040
  }
3741
2041
  const data = await parseBody(output.body, context);
3742
2042
  let contents = {};
@@ -3747,31 +2047,9 @@ var de_UpdateBandwidthRateLimitScheduleCommand = /* @__PURE__ */ __name(async (o
3747
2047
  };
3748
2048
  return response;
3749
2049
  }, "de_UpdateBandwidthRateLimitScheduleCommand");
3750
- var de_UpdateBandwidthRateLimitScheduleCommandError = /* @__PURE__ */ __name(async (output, context) => {
3751
- const parsedOutput = {
3752
- ...output,
3753
- body: await parseErrorBody(output.body, context)
3754
- };
3755
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3756
- switch (errorCode) {
3757
- case "InternalServerError":
3758
- case "com.amazonaws.storagegateway#InternalServerError":
3759
- throw await de_InternalServerErrorRes(parsedOutput, context);
3760
- case "InvalidGatewayRequestException":
3761
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3762
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3763
- default:
3764
- const parsedBody = parsedOutput.body;
3765
- return throwDefaultError({
3766
- output,
3767
- parsedBody,
3768
- errorCode
3769
- });
3770
- }
3771
- }, "de_UpdateBandwidthRateLimitScheduleCommandError");
3772
2050
  var de_UpdateChapCredentialsCommand = /* @__PURE__ */ __name(async (output, context) => {
3773
2051
  if (output.statusCode >= 300) {
3774
- return de_UpdateChapCredentialsCommandError(output, context);
2052
+ return de_CommandError(output, context);
3775
2053
  }
3776
2054
  const data = await parseBody(output.body, context);
3777
2055
  let contents = {};
@@ -3782,31 +2060,9 @@ var de_UpdateChapCredentialsCommand = /* @__PURE__ */ __name(async (output, cont
3782
2060
  };
3783
2061
  return response;
3784
2062
  }, "de_UpdateChapCredentialsCommand");
3785
- var de_UpdateChapCredentialsCommandError = /* @__PURE__ */ __name(async (output, context) => {
3786
- const parsedOutput = {
3787
- ...output,
3788
- body: await parseErrorBody(output.body, context)
3789
- };
3790
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3791
- switch (errorCode) {
3792
- case "InternalServerError":
3793
- case "com.amazonaws.storagegateway#InternalServerError":
3794
- throw await de_InternalServerErrorRes(parsedOutput, context);
3795
- case "InvalidGatewayRequestException":
3796
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3797
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3798
- default:
3799
- const parsedBody = parsedOutput.body;
3800
- return throwDefaultError({
3801
- output,
3802
- parsedBody,
3803
- errorCode
3804
- });
3805
- }
3806
- }, "de_UpdateChapCredentialsCommandError");
3807
2063
  var de_UpdateFileSystemAssociationCommand = /* @__PURE__ */ __name(async (output, context) => {
3808
2064
  if (output.statusCode >= 300) {
3809
- return de_UpdateFileSystemAssociationCommandError(output, context);
2065
+ return de_CommandError(output, context);
3810
2066
  }
3811
2067
  const data = await parseBody(output.body, context);
3812
2068
  let contents = {};
@@ -3817,31 +2073,9 @@ var de_UpdateFileSystemAssociationCommand = /* @__PURE__ */ __name(async (output
3817
2073
  };
3818
2074
  return response;
3819
2075
  }, "de_UpdateFileSystemAssociationCommand");
3820
- var de_UpdateFileSystemAssociationCommandError = /* @__PURE__ */ __name(async (output, context) => {
3821
- const parsedOutput = {
3822
- ...output,
3823
- body: await parseErrorBody(output.body, context)
3824
- };
3825
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3826
- switch (errorCode) {
3827
- case "InternalServerError":
3828
- case "com.amazonaws.storagegateway#InternalServerError":
3829
- throw await de_InternalServerErrorRes(parsedOutput, context);
3830
- case "InvalidGatewayRequestException":
3831
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3832
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3833
- default:
3834
- const parsedBody = parsedOutput.body;
3835
- return throwDefaultError({
3836
- output,
3837
- parsedBody,
3838
- errorCode
3839
- });
3840
- }
3841
- }, "de_UpdateFileSystemAssociationCommandError");
3842
2076
  var de_UpdateGatewayInformationCommand = /* @__PURE__ */ __name(async (output, context) => {
3843
2077
  if (output.statusCode >= 300) {
3844
- return de_UpdateGatewayInformationCommandError(output, context);
2078
+ return de_CommandError(output, context);
3845
2079
  }
3846
2080
  const data = await parseBody(output.body, context);
3847
2081
  let contents = {};
@@ -3852,31 +2086,9 @@ var de_UpdateGatewayInformationCommand = /* @__PURE__ */ __name(async (output, c
3852
2086
  };
3853
2087
  return response;
3854
2088
  }, "de_UpdateGatewayInformationCommand");
3855
- var de_UpdateGatewayInformationCommandError = /* @__PURE__ */ __name(async (output, context) => {
3856
- const parsedOutput = {
3857
- ...output,
3858
- body: await parseErrorBody(output.body, context)
3859
- };
3860
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3861
- switch (errorCode) {
3862
- case "InternalServerError":
3863
- case "com.amazonaws.storagegateway#InternalServerError":
3864
- throw await de_InternalServerErrorRes(parsedOutput, context);
3865
- case "InvalidGatewayRequestException":
3866
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3867
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3868
- default:
3869
- const parsedBody = parsedOutput.body;
3870
- return throwDefaultError({
3871
- output,
3872
- parsedBody,
3873
- errorCode
3874
- });
3875
- }
3876
- }, "de_UpdateGatewayInformationCommandError");
3877
2089
  var de_UpdateGatewaySoftwareNowCommand = /* @__PURE__ */ __name(async (output, context) => {
3878
2090
  if (output.statusCode >= 300) {
3879
- return de_UpdateGatewaySoftwareNowCommandError(output, context);
2091
+ return de_CommandError(output, context);
3880
2092
  }
3881
2093
  const data = await parseBody(output.body, context);
3882
2094
  let contents = {};
@@ -3887,31 +2099,9 @@ var de_UpdateGatewaySoftwareNowCommand = /* @__PURE__ */ __name(async (output, c
3887
2099
  };
3888
2100
  return response;
3889
2101
  }, "de_UpdateGatewaySoftwareNowCommand");
3890
- var de_UpdateGatewaySoftwareNowCommandError = /* @__PURE__ */ __name(async (output, context) => {
3891
- const parsedOutput = {
3892
- ...output,
3893
- body: await parseErrorBody(output.body, context)
3894
- };
3895
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3896
- switch (errorCode) {
3897
- case "InternalServerError":
3898
- case "com.amazonaws.storagegateway#InternalServerError":
3899
- throw await de_InternalServerErrorRes(parsedOutput, context);
3900
- case "InvalidGatewayRequestException":
3901
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3902
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3903
- default:
3904
- const parsedBody = parsedOutput.body;
3905
- return throwDefaultError({
3906
- output,
3907
- parsedBody,
3908
- errorCode
3909
- });
3910
- }
3911
- }, "de_UpdateGatewaySoftwareNowCommandError");
3912
2102
  var de_UpdateMaintenanceStartTimeCommand = /* @__PURE__ */ __name(async (output, context) => {
3913
2103
  if (output.statusCode >= 300) {
3914
- return de_UpdateMaintenanceStartTimeCommandError(output, context);
2104
+ return de_CommandError(output, context);
3915
2105
  }
3916
2106
  const data = await parseBody(output.body, context);
3917
2107
  let contents = {};
@@ -3922,31 +2112,9 @@ var de_UpdateMaintenanceStartTimeCommand = /* @__PURE__ */ __name(async (output,
3922
2112
  };
3923
2113
  return response;
3924
2114
  }, "de_UpdateMaintenanceStartTimeCommand");
3925
- var de_UpdateMaintenanceStartTimeCommandError = /* @__PURE__ */ __name(async (output, context) => {
3926
- const parsedOutput = {
3927
- ...output,
3928
- body: await parseErrorBody(output.body, context)
3929
- };
3930
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3931
- switch (errorCode) {
3932
- case "InternalServerError":
3933
- case "com.amazonaws.storagegateway#InternalServerError":
3934
- throw await de_InternalServerErrorRes(parsedOutput, context);
3935
- case "InvalidGatewayRequestException":
3936
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3937
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3938
- default:
3939
- const parsedBody = parsedOutput.body;
3940
- return throwDefaultError({
3941
- output,
3942
- parsedBody,
3943
- errorCode
3944
- });
3945
- }
3946
- }, "de_UpdateMaintenanceStartTimeCommandError");
3947
2115
  var de_UpdateNFSFileShareCommand = /* @__PURE__ */ __name(async (output, context) => {
3948
2116
  if (output.statusCode >= 300) {
3949
- return de_UpdateNFSFileShareCommandError(output, context);
2117
+ return de_CommandError(output, context);
3950
2118
  }
3951
2119
  const data = await parseBody(output.body, context);
3952
2120
  let contents = {};
@@ -3957,31 +2125,9 @@ var de_UpdateNFSFileShareCommand = /* @__PURE__ */ __name(async (output, context
3957
2125
  };
3958
2126
  return response;
3959
2127
  }, "de_UpdateNFSFileShareCommand");
3960
- var de_UpdateNFSFileShareCommandError = /* @__PURE__ */ __name(async (output, context) => {
3961
- const parsedOutput = {
3962
- ...output,
3963
- body: await parseErrorBody(output.body, context)
3964
- };
3965
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3966
- switch (errorCode) {
3967
- case "InternalServerError":
3968
- case "com.amazonaws.storagegateway#InternalServerError":
3969
- throw await de_InternalServerErrorRes(parsedOutput, context);
3970
- case "InvalidGatewayRequestException":
3971
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
3972
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
3973
- default:
3974
- const parsedBody = parsedOutput.body;
3975
- return throwDefaultError({
3976
- output,
3977
- parsedBody,
3978
- errorCode
3979
- });
3980
- }
3981
- }, "de_UpdateNFSFileShareCommandError");
3982
2128
  var de_UpdateSMBFileShareCommand = /* @__PURE__ */ __name(async (output, context) => {
3983
2129
  if (output.statusCode >= 300) {
3984
- return de_UpdateSMBFileShareCommandError(output, context);
2130
+ return de_CommandError(output, context);
3985
2131
  }
3986
2132
  const data = await parseBody(output.body, context);
3987
2133
  let contents = {};
@@ -3992,31 +2138,9 @@ var de_UpdateSMBFileShareCommand = /* @__PURE__ */ __name(async (output, context
3992
2138
  };
3993
2139
  return response;
3994
2140
  }, "de_UpdateSMBFileShareCommand");
3995
- var de_UpdateSMBFileShareCommandError = /* @__PURE__ */ __name(async (output, context) => {
3996
- const parsedOutput = {
3997
- ...output,
3998
- body: await parseErrorBody(output.body, context)
3999
- };
4000
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4001
- switch (errorCode) {
4002
- case "InternalServerError":
4003
- case "com.amazonaws.storagegateway#InternalServerError":
4004
- throw await de_InternalServerErrorRes(parsedOutput, context);
4005
- case "InvalidGatewayRequestException":
4006
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
4007
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
4008
- default:
4009
- const parsedBody = parsedOutput.body;
4010
- return throwDefaultError({
4011
- output,
4012
- parsedBody,
4013
- errorCode
4014
- });
4015
- }
4016
- }, "de_UpdateSMBFileShareCommandError");
4017
2141
  var de_UpdateSMBFileShareVisibilityCommand = /* @__PURE__ */ __name(async (output, context) => {
4018
2142
  if (output.statusCode >= 300) {
4019
- return de_UpdateSMBFileShareVisibilityCommandError(output, context);
2143
+ return de_CommandError(output, context);
4020
2144
  }
4021
2145
  const data = await parseBody(output.body, context);
4022
2146
  let contents = {};
@@ -4027,31 +2151,9 @@ var de_UpdateSMBFileShareVisibilityCommand = /* @__PURE__ */ __name(async (outpu
4027
2151
  };
4028
2152
  return response;
4029
2153
  }, "de_UpdateSMBFileShareVisibilityCommand");
4030
- var de_UpdateSMBFileShareVisibilityCommandError = /* @__PURE__ */ __name(async (output, context) => {
4031
- const parsedOutput = {
4032
- ...output,
4033
- body: await parseErrorBody(output.body, context)
4034
- };
4035
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4036
- switch (errorCode) {
4037
- case "InternalServerError":
4038
- case "com.amazonaws.storagegateway#InternalServerError":
4039
- throw await de_InternalServerErrorRes(parsedOutput, context);
4040
- case "InvalidGatewayRequestException":
4041
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
4042
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
4043
- default:
4044
- const parsedBody = parsedOutput.body;
4045
- return throwDefaultError({
4046
- output,
4047
- parsedBody,
4048
- errorCode
4049
- });
4050
- }
4051
- }, "de_UpdateSMBFileShareVisibilityCommandError");
4052
2154
  var de_UpdateSMBLocalGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
4053
2155
  if (output.statusCode >= 300) {
4054
- return de_UpdateSMBLocalGroupsCommandError(output, context);
2156
+ return de_CommandError(output, context);
4055
2157
  }
4056
2158
  const data = await parseBody(output.body, context);
4057
2159
  let contents = {};
@@ -4062,31 +2164,9 @@ var de_UpdateSMBLocalGroupsCommand = /* @__PURE__ */ __name(async (output, conte
4062
2164
  };
4063
2165
  return response;
4064
2166
  }, "de_UpdateSMBLocalGroupsCommand");
4065
- var de_UpdateSMBLocalGroupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
4066
- const parsedOutput = {
4067
- ...output,
4068
- body: await parseErrorBody(output.body, context)
4069
- };
4070
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4071
- switch (errorCode) {
4072
- case "InternalServerError":
4073
- case "com.amazonaws.storagegateway#InternalServerError":
4074
- throw await de_InternalServerErrorRes(parsedOutput, context);
4075
- case "InvalidGatewayRequestException":
4076
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
4077
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
4078
- default:
4079
- const parsedBody = parsedOutput.body;
4080
- return throwDefaultError({
4081
- output,
4082
- parsedBody,
4083
- errorCode
4084
- });
4085
- }
4086
- }, "de_UpdateSMBLocalGroupsCommandError");
4087
2167
  var de_UpdateSMBSecurityStrategyCommand = /* @__PURE__ */ __name(async (output, context) => {
4088
2168
  if (output.statusCode >= 300) {
4089
- return de_UpdateSMBSecurityStrategyCommandError(output, context);
2169
+ return de_CommandError(output, context);
4090
2170
  }
4091
2171
  const data = await parseBody(output.body, context);
4092
2172
  let contents = {};
@@ -4097,31 +2177,9 @@ var de_UpdateSMBSecurityStrategyCommand = /* @__PURE__ */ __name(async (output,
4097
2177
  };
4098
2178
  return response;
4099
2179
  }, "de_UpdateSMBSecurityStrategyCommand");
4100
- var de_UpdateSMBSecurityStrategyCommandError = /* @__PURE__ */ __name(async (output, context) => {
4101
- const parsedOutput = {
4102
- ...output,
4103
- body: await parseErrorBody(output.body, context)
4104
- };
4105
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4106
- switch (errorCode) {
4107
- case "InternalServerError":
4108
- case "com.amazonaws.storagegateway#InternalServerError":
4109
- throw await de_InternalServerErrorRes(parsedOutput, context);
4110
- case "InvalidGatewayRequestException":
4111
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
4112
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
4113
- default:
4114
- const parsedBody = parsedOutput.body;
4115
- return throwDefaultError({
4116
- output,
4117
- parsedBody,
4118
- errorCode
4119
- });
4120
- }
4121
- }, "de_UpdateSMBSecurityStrategyCommandError");
4122
2180
  var de_UpdateSnapshotScheduleCommand = /* @__PURE__ */ __name(async (output, context) => {
4123
2181
  if (output.statusCode >= 300) {
4124
- return de_UpdateSnapshotScheduleCommandError(output, context);
2182
+ return de_CommandError(output, context);
4125
2183
  }
4126
2184
  const data = await parseBody(output.body, context);
4127
2185
  let contents = {};
@@ -4132,31 +2190,9 @@ var de_UpdateSnapshotScheduleCommand = /* @__PURE__ */ __name(async (output, con
4132
2190
  };
4133
2191
  return response;
4134
2192
  }, "de_UpdateSnapshotScheduleCommand");
4135
- var de_UpdateSnapshotScheduleCommandError = /* @__PURE__ */ __name(async (output, context) => {
4136
- const parsedOutput = {
4137
- ...output,
4138
- body: await parseErrorBody(output.body, context)
4139
- };
4140
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4141
- switch (errorCode) {
4142
- case "InternalServerError":
4143
- case "com.amazonaws.storagegateway#InternalServerError":
4144
- throw await de_InternalServerErrorRes(parsedOutput, context);
4145
- case "InvalidGatewayRequestException":
4146
- case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
4147
- throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
4148
- default:
4149
- const parsedBody = parsedOutput.body;
4150
- return throwDefaultError({
4151
- output,
4152
- parsedBody,
4153
- errorCode
4154
- });
4155
- }
4156
- }, "de_UpdateSnapshotScheduleCommandError");
4157
2193
  var de_UpdateVTLDeviceTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
4158
2194
  if (output.statusCode >= 300) {
4159
- return de_UpdateVTLDeviceTypeCommandError(output, context);
2195
+ return de_CommandError(output, context);
4160
2196
  }
4161
2197
  const data = await parseBody(output.body, context);
4162
2198
  let contents = {};
@@ -4167,7 +2203,7 @@ var de_UpdateVTLDeviceTypeCommand = /* @__PURE__ */ __name(async (output, contex
4167
2203
  };
4168
2204
  return response;
4169
2205
  }, "de_UpdateVTLDeviceTypeCommand");
4170
- var de_UpdateVTLDeviceTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
2206
+ var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
4171
2207
  const parsedOutput = {
4172
2208
  ...output,
4173
2209
  body: await parseErrorBody(output.body, context)
@@ -4180,6 +2216,9 @@ var de_UpdateVTLDeviceTypeCommandError = /* @__PURE__ */ __name(async (output, c
4180
2216
  case "InvalidGatewayRequestException":
4181
2217
  case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
4182
2218
  throw await de_InvalidGatewayRequestExceptionRes(parsedOutput, context);
2219
+ case "ServiceUnavailableError":
2220
+ case "com.amazonaws.storagegateway#ServiceUnavailableError":
2221
+ throw await de_ServiceUnavailableErrorRes(parsedOutput, context);
4183
2222
  default:
4184
2223
  const parsedBody = parsedOutput.body;
4185
2224
  return throwDefaultError({
@@ -4188,7 +2227,7 @@ var de_UpdateVTLDeviceTypeCommandError = /* @__PURE__ */ __name(async (output, c
4188
2227
  errorCode
4189
2228
  });
4190
2229
  }
4191
- }, "de_UpdateVTLDeviceTypeCommandError");
2230
+ }, "de_CommandError");
4192
2231
  var de_InternalServerErrorRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
4193
2232
  const body = parsedOutput.body;
4194
2233
  const deserialized = (0, import_smithy_client._json)(body);