@aws-sdk/client-datasync 3.503.1 → 3.507.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist-cjs/index.js CHANGED
@@ -1053,7 +1053,7 @@ var se_UpdateTaskExecutionCommand = /* @__PURE__ */ __name(async (input, context
1053
1053
  }, "se_UpdateTaskExecutionCommand");
1054
1054
  var de_AddStorageSystemCommand = /* @__PURE__ */ __name(async (output, context) => {
1055
1055
  if (output.statusCode >= 300) {
1056
- return de_AddStorageSystemCommandError(output, context);
1056
+ return de_CommandError(output, context);
1057
1057
  }
1058
1058
  const data = await parseBody(output.body, context);
1059
1059
  let contents = {};
@@ -1064,31 +1064,9 @@ var de_AddStorageSystemCommand = /* @__PURE__ */ __name(async (output, context)
1064
1064
  };
1065
1065
  return response;
1066
1066
  }, "de_AddStorageSystemCommand");
1067
- var de_AddStorageSystemCommandError = /* @__PURE__ */ __name(async (output, context) => {
1068
- const parsedOutput = {
1069
- ...output,
1070
- body: await parseErrorBody(output.body, context)
1071
- };
1072
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1073
- switch (errorCode) {
1074
- case "InternalException":
1075
- case "com.amazonaws.datasync#InternalException":
1076
- throw await de_InternalExceptionRes(parsedOutput, context);
1077
- case "InvalidRequestException":
1078
- case "com.amazonaws.datasync#InvalidRequestException":
1079
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1080
- default:
1081
- const parsedBody = parsedOutput.body;
1082
- return throwDefaultError({
1083
- output,
1084
- parsedBody,
1085
- errorCode
1086
- });
1087
- }
1088
- }, "de_AddStorageSystemCommandError");
1089
1067
  var de_CancelTaskExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
1090
1068
  if (output.statusCode >= 300) {
1091
- return de_CancelTaskExecutionCommandError(output, context);
1069
+ return de_CommandError(output, context);
1092
1070
  }
1093
1071
  const data = await parseBody(output.body, context);
1094
1072
  let contents = {};
@@ -1099,31 +1077,9 @@ var de_CancelTaskExecutionCommand = /* @__PURE__ */ __name(async (output, contex
1099
1077
  };
1100
1078
  return response;
1101
1079
  }, "de_CancelTaskExecutionCommand");
1102
- var de_CancelTaskExecutionCommandError = /* @__PURE__ */ __name(async (output, context) => {
1103
- const parsedOutput = {
1104
- ...output,
1105
- body: await parseErrorBody(output.body, context)
1106
- };
1107
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1108
- switch (errorCode) {
1109
- case "InternalException":
1110
- case "com.amazonaws.datasync#InternalException":
1111
- throw await de_InternalExceptionRes(parsedOutput, context);
1112
- case "InvalidRequestException":
1113
- case "com.amazonaws.datasync#InvalidRequestException":
1114
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1115
- default:
1116
- const parsedBody = parsedOutput.body;
1117
- return throwDefaultError({
1118
- output,
1119
- parsedBody,
1120
- errorCode
1121
- });
1122
- }
1123
- }, "de_CancelTaskExecutionCommandError");
1124
1080
  var de_CreateAgentCommand = /* @__PURE__ */ __name(async (output, context) => {
1125
1081
  if (output.statusCode >= 300) {
1126
- return de_CreateAgentCommandError(output, context);
1082
+ return de_CommandError(output, context);
1127
1083
  }
1128
1084
  const data = await parseBody(output.body, context);
1129
1085
  let contents = {};
@@ -1134,31 +1090,9 @@ var de_CreateAgentCommand = /* @__PURE__ */ __name(async (output, context) => {
1134
1090
  };
1135
1091
  return response;
1136
1092
  }, "de_CreateAgentCommand");
1137
- var de_CreateAgentCommandError = /* @__PURE__ */ __name(async (output, context) => {
1138
- const parsedOutput = {
1139
- ...output,
1140
- body: await parseErrorBody(output.body, context)
1141
- };
1142
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1143
- switch (errorCode) {
1144
- case "InternalException":
1145
- case "com.amazonaws.datasync#InternalException":
1146
- throw await de_InternalExceptionRes(parsedOutput, context);
1147
- case "InvalidRequestException":
1148
- case "com.amazonaws.datasync#InvalidRequestException":
1149
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1150
- default:
1151
- const parsedBody = parsedOutput.body;
1152
- return throwDefaultError({
1153
- output,
1154
- parsedBody,
1155
- errorCode
1156
- });
1157
- }
1158
- }, "de_CreateAgentCommandError");
1159
1093
  var de_CreateLocationAzureBlobCommand = /* @__PURE__ */ __name(async (output, context) => {
1160
1094
  if (output.statusCode >= 300) {
1161
- return de_CreateLocationAzureBlobCommandError(output, context);
1095
+ return de_CommandError(output, context);
1162
1096
  }
1163
1097
  const data = await parseBody(output.body, context);
1164
1098
  let contents = {};
@@ -1169,31 +1103,9 @@ var de_CreateLocationAzureBlobCommand = /* @__PURE__ */ __name(async (output, co
1169
1103
  };
1170
1104
  return response;
1171
1105
  }, "de_CreateLocationAzureBlobCommand");
1172
- var de_CreateLocationAzureBlobCommandError = /* @__PURE__ */ __name(async (output, context) => {
1173
- const parsedOutput = {
1174
- ...output,
1175
- body: await parseErrorBody(output.body, context)
1176
- };
1177
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1178
- switch (errorCode) {
1179
- case "InternalException":
1180
- case "com.amazonaws.datasync#InternalException":
1181
- throw await de_InternalExceptionRes(parsedOutput, context);
1182
- case "InvalidRequestException":
1183
- case "com.amazonaws.datasync#InvalidRequestException":
1184
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1185
- default:
1186
- const parsedBody = parsedOutput.body;
1187
- return throwDefaultError({
1188
- output,
1189
- parsedBody,
1190
- errorCode
1191
- });
1192
- }
1193
- }, "de_CreateLocationAzureBlobCommandError");
1194
1106
  var de_CreateLocationEfsCommand = /* @__PURE__ */ __name(async (output, context) => {
1195
1107
  if (output.statusCode >= 300) {
1196
- return de_CreateLocationEfsCommandError(output, context);
1108
+ return de_CommandError(output, context);
1197
1109
  }
1198
1110
  const data = await parseBody(output.body, context);
1199
1111
  let contents = {};
@@ -1204,31 +1116,9 @@ var de_CreateLocationEfsCommand = /* @__PURE__ */ __name(async (output, context)
1204
1116
  };
1205
1117
  return response;
1206
1118
  }, "de_CreateLocationEfsCommand");
1207
- var de_CreateLocationEfsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1208
- const parsedOutput = {
1209
- ...output,
1210
- body: await parseErrorBody(output.body, context)
1211
- };
1212
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1213
- switch (errorCode) {
1214
- case "InternalException":
1215
- case "com.amazonaws.datasync#InternalException":
1216
- throw await de_InternalExceptionRes(parsedOutput, context);
1217
- case "InvalidRequestException":
1218
- case "com.amazonaws.datasync#InvalidRequestException":
1219
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1220
- default:
1221
- const parsedBody = parsedOutput.body;
1222
- return throwDefaultError({
1223
- output,
1224
- parsedBody,
1225
- errorCode
1226
- });
1227
- }
1228
- }, "de_CreateLocationEfsCommandError");
1229
1119
  var de_CreateLocationFsxLustreCommand = /* @__PURE__ */ __name(async (output, context) => {
1230
1120
  if (output.statusCode >= 300) {
1231
- return de_CreateLocationFsxLustreCommandError(output, context);
1121
+ return de_CommandError(output, context);
1232
1122
  }
1233
1123
  const data = await parseBody(output.body, context);
1234
1124
  let contents = {};
@@ -1239,31 +1129,9 @@ var de_CreateLocationFsxLustreCommand = /* @__PURE__ */ __name(async (output, co
1239
1129
  };
1240
1130
  return response;
1241
1131
  }, "de_CreateLocationFsxLustreCommand");
1242
- var de_CreateLocationFsxLustreCommandError = /* @__PURE__ */ __name(async (output, context) => {
1243
- const parsedOutput = {
1244
- ...output,
1245
- body: await parseErrorBody(output.body, context)
1246
- };
1247
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1248
- switch (errorCode) {
1249
- case "InternalException":
1250
- case "com.amazonaws.datasync#InternalException":
1251
- throw await de_InternalExceptionRes(parsedOutput, context);
1252
- case "InvalidRequestException":
1253
- case "com.amazonaws.datasync#InvalidRequestException":
1254
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1255
- default:
1256
- const parsedBody = parsedOutput.body;
1257
- return throwDefaultError({
1258
- output,
1259
- parsedBody,
1260
- errorCode
1261
- });
1262
- }
1263
- }, "de_CreateLocationFsxLustreCommandError");
1264
1132
  var de_CreateLocationFsxOntapCommand = /* @__PURE__ */ __name(async (output, context) => {
1265
1133
  if (output.statusCode >= 300) {
1266
- return de_CreateLocationFsxOntapCommandError(output, context);
1134
+ return de_CommandError(output, context);
1267
1135
  }
1268
1136
  const data = await parseBody(output.body, context);
1269
1137
  let contents = {};
@@ -1274,31 +1142,9 @@ var de_CreateLocationFsxOntapCommand = /* @__PURE__ */ __name(async (output, con
1274
1142
  };
1275
1143
  return response;
1276
1144
  }, "de_CreateLocationFsxOntapCommand");
1277
- var de_CreateLocationFsxOntapCommandError = /* @__PURE__ */ __name(async (output, context) => {
1278
- const parsedOutput = {
1279
- ...output,
1280
- body: await parseErrorBody(output.body, context)
1281
- };
1282
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1283
- switch (errorCode) {
1284
- case "InternalException":
1285
- case "com.amazonaws.datasync#InternalException":
1286
- throw await de_InternalExceptionRes(parsedOutput, context);
1287
- case "InvalidRequestException":
1288
- case "com.amazonaws.datasync#InvalidRequestException":
1289
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1290
- default:
1291
- const parsedBody = parsedOutput.body;
1292
- return throwDefaultError({
1293
- output,
1294
- parsedBody,
1295
- errorCode
1296
- });
1297
- }
1298
- }, "de_CreateLocationFsxOntapCommandError");
1299
1145
  var de_CreateLocationFsxOpenZfsCommand = /* @__PURE__ */ __name(async (output, context) => {
1300
1146
  if (output.statusCode >= 300) {
1301
- return de_CreateLocationFsxOpenZfsCommandError(output, context);
1147
+ return de_CommandError(output, context);
1302
1148
  }
1303
1149
  const data = await parseBody(output.body, context);
1304
1150
  let contents = {};
@@ -1309,31 +1155,9 @@ var de_CreateLocationFsxOpenZfsCommand = /* @__PURE__ */ __name(async (output, c
1309
1155
  };
1310
1156
  return response;
1311
1157
  }, "de_CreateLocationFsxOpenZfsCommand");
1312
- var de_CreateLocationFsxOpenZfsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1313
- const parsedOutput = {
1314
- ...output,
1315
- body: await parseErrorBody(output.body, context)
1316
- };
1317
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1318
- switch (errorCode) {
1319
- case "InternalException":
1320
- case "com.amazonaws.datasync#InternalException":
1321
- throw await de_InternalExceptionRes(parsedOutput, context);
1322
- case "InvalidRequestException":
1323
- case "com.amazonaws.datasync#InvalidRequestException":
1324
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1325
- default:
1326
- const parsedBody = parsedOutput.body;
1327
- return throwDefaultError({
1328
- output,
1329
- parsedBody,
1330
- errorCode
1331
- });
1332
- }
1333
- }, "de_CreateLocationFsxOpenZfsCommandError");
1334
1158
  var de_CreateLocationFsxWindowsCommand = /* @__PURE__ */ __name(async (output, context) => {
1335
1159
  if (output.statusCode >= 300) {
1336
- return de_CreateLocationFsxWindowsCommandError(output, context);
1160
+ return de_CommandError(output, context);
1337
1161
  }
1338
1162
  const data = await parseBody(output.body, context);
1339
1163
  let contents = {};
@@ -1344,31 +1168,9 @@ var de_CreateLocationFsxWindowsCommand = /* @__PURE__ */ __name(async (output, c
1344
1168
  };
1345
1169
  return response;
1346
1170
  }, "de_CreateLocationFsxWindowsCommand");
1347
- var de_CreateLocationFsxWindowsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1348
- const parsedOutput = {
1349
- ...output,
1350
- body: await parseErrorBody(output.body, context)
1351
- };
1352
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1353
- switch (errorCode) {
1354
- case "InternalException":
1355
- case "com.amazonaws.datasync#InternalException":
1356
- throw await de_InternalExceptionRes(parsedOutput, context);
1357
- case "InvalidRequestException":
1358
- case "com.amazonaws.datasync#InvalidRequestException":
1359
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1360
- default:
1361
- const parsedBody = parsedOutput.body;
1362
- return throwDefaultError({
1363
- output,
1364
- parsedBody,
1365
- errorCode
1366
- });
1367
- }
1368
- }, "de_CreateLocationFsxWindowsCommandError");
1369
1171
  var de_CreateLocationHdfsCommand = /* @__PURE__ */ __name(async (output, context) => {
1370
1172
  if (output.statusCode >= 300) {
1371
- return de_CreateLocationHdfsCommandError(output, context);
1173
+ return de_CommandError(output, context);
1372
1174
  }
1373
1175
  const data = await parseBody(output.body, context);
1374
1176
  let contents = {};
@@ -1379,31 +1181,9 @@ var de_CreateLocationHdfsCommand = /* @__PURE__ */ __name(async (output, context
1379
1181
  };
1380
1182
  return response;
1381
1183
  }, "de_CreateLocationHdfsCommand");
1382
- var de_CreateLocationHdfsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1383
- const parsedOutput = {
1384
- ...output,
1385
- body: await parseErrorBody(output.body, context)
1386
- };
1387
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1388
- switch (errorCode) {
1389
- case "InternalException":
1390
- case "com.amazonaws.datasync#InternalException":
1391
- throw await de_InternalExceptionRes(parsedOutput, context);
1392
- case "InvalidRequestException":
1393
- case "com.amazonaws.datasync#InvalidRequestException":
1394
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1395
- default:
1396
- const parsedBody = parsedOutput.body;
1397
- return throwDefaultError({
1398
- output,
1399
- parsedBody,
1400
- errorCode
1401
- });
1402
- }
1403
- }, "de_CreateLocationHdfsCommandError");
1404
1184
  var de_CreateLocationNfsCommand = /* @__PURE__ */ __name(async (output, context) => {
1405
1185
  if (output.statusCode >= 300) {
1406
- return de_CreateLocationNfsCommandError(output, context);
1186
+ return de_CommandError(output, context);
1407
1187
  }
1408
1188
  const data = await parseBody(output.body, context);
1409
1189
  let contents = {};
@@ -1414,31 +1194,9 @@ var de_CreateLocationNfsCommand = /* @__PURE__ */ __name(async (output, context)
1414
1194
  };
1415
1195
  return response;
1416
1196
  }, "de_CreateLocationNfsCommand");
1417
- var de_CreateLocationNfsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1418
- const parsedOutput = {
1419
- ...output,
1420
- body: await parseErrorBody(output.body, context)
1421
- };
1422
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1423
- switch (errorCode) {
1424
- case "InternalException":
1425
- case "com.amazonaws.datasync#InternalException":
1426
- throw await de_InternalExceptionRes(parsedOutput, context);
1427
- case "InvalidRequestException":
1428
- case "com.amazonaws.datasync#InvalidRequestException":
1429
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1430
- default:
1431
- const parsedBody = parsedOutput.body;
1432
- return throwDefaultError({
1433
- output,
1434
- parsedBody,
1435
- errorCode
1436
- });
1437
- }
1438
- }, "de_CreateLocationNfsCommandError");
1439
1197
  var de_CreateLocationObjectStorageCommand = /* @__PURE__ */ __name(async (output, context) => {
1440
1198
  if (output.statusCode >= 300) {
1441
- return de_CreateLocationObjectStorageCommandError(output, context);
1199
+ return de_CommandError(output, context);
1442
1200
  }
1443
1201
  const data = await parseBody(output.body, context);
1444
1202
  let contents = {};
@@ -1449,31 +1207,9 @@ var de_CreateLocationObjectStorageCommand = /* @__PURE__ */ __name(async (output
1449
1207
  };
1450
1208
  return response;
1451
1209
  }, "de_CreateLocationObjectStorageCommand");
1452
- var de_CreateLocationObjectStorageCommandError = /* @__PURE__ */ __name(async (output, context) => {
1453
- const parsedOutput = {
1454
- ...output,
1455
- body: await parseErrorBody(output.body, context)
1456
- };
1457
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1458
- switch (errorCode) {
1459
- case "InternalException":
1460
- case "com.amazonaws.datasync#InternalException":
1461
- throw await de_InternalExceptionRes(parsedOutput, context);
1462
- case "InvalidRequestException":
1463
- case "com.amazonaws.datasync#InvalidRequestException":
1464
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1465
- default:
1466
- const parsedBody = parsedOutput.body;
1467
- return throwDefaultError({
1468
- output,
1469
- parsedBody,
1470
- errorCode
1471
- });
1472
- }
1473
- }, "de_CreateLocationObjectStorageCommandError");
1474
1210
  var de_CreateLocationS3Command = /* @__PURE__ */ __name(async (output, context) => {
1475
1211
  if (output.statusCode >= 300) {
1476
- return de_CreateLocationS3CommandError(output, context);
1212
+ return de_CommandError(output, context);
1477
1213
  }
1478
1214
  const data = await parseBody(output.body, context);
1479
1215
  let contents = {};
@@ -1484,66 +1220,22 @@ var de_CreateLocationS3Command = /* @__PURE__ */ __name(async (output, context)
1484
1220
  };
1485
1221
  return response;
1486
1222
  }, "de_CreateLocationS3Command");
1487
- var de_CreateLocationS3CommandError = /* @__PURE__ */ __name(async (output, context) => {
1488
- const parsedOutput = {
1489
- ...output,
1490
- body: await parseErrorBody(output.body, context)
1491
- };
1492
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1493
- switch (errorCode) {
1494
- case "InternalException":
1495
- case "com.amazonaws.datasync#InternalException":
1496
- throw await de_InternalExceptionRes(parsedOutput, context);
1497
- case "InvalidRequestException":
1498
- case "com.amazonaws.datasync#InvalidRequestException":
1499
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1500
- default:
1501
- const parsedBody = parsedOutput.body;
1502
- return throwDefaultError({
1503
- output,
1504
- parsedBody,
1505
- errorCode
1506
- });
1507
- }
1508
- }, "de_CreateLocationS3CommandError");
1509
- var de_CreateLocationSmbCommand = /* @__PURE__ */ __name(async (output, context) => {
1510
- if (output.statusCode >= 300) {
1511
- return de_CreateLocationSmbCommandError(output, context);
1512
- }
1513
- const data = await parseBody(output.body, context);
1514
- let contents = {};
1515
- contents = (0, import_smithy_client._json)(data);
1516
- const response = {
1517
- $metadata: deserializeMetadata(output),
1518
- ...contents
1223
+ var de_CreateLocationSmbCommand = /* @__PURE__ */ __name(async (output, context) => {
1224
+ if (output.statusCode >= 300) {
1225
+ return de_CommandError(output, context);
1226
+ }
1227
+ const data = await parseBody(output.body, context);
1228
+ let contents = {};
1229
+ contents = (0, import_smithy_client._json)(data);
1230
+ const response = {
1231
+ $metadata: deserializeMetadata(output),
1232
+ ...contents
1519
1233
  };
1520
1234
  return response;
1521
1235
  }, "de_CreateLocationSmbCommand");
1522
- var de_CreateLocationSmbCommandError = /* @__PURE__ */ __name(async (output, context) => {
1523
- const parsedOutput = {
1524
- ...output,
1525
- body: await parseErrorBody(output.body, context)
1526
- };
1527
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1528
- switch (errorCode) {
1529
- case "InternalException":
1530
- case "com.amazonaws.datasync#InternalException":
1531
- throw await de_InternalExceptionRes(parsedOutput, context);
1532
- case "InvalidRequestException":
1533
- case "com.amazonaws.datasync#InvalidRequestException":
1534
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1535
- default:
1536
- const parsedBody = parsedOutput.body;
1537
- return throwDefaultError({
1538
- output,
1539
- parsedBody,
1540
- errorCode
1541
- });
1542
- }
1543
- }, "de_CreateLocationSmbCommandError");
1544
1236
  var de_CreateTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
1545
1237
  if (output.statusCode >= 300) {
1546
- return de_CreateTaskCommandError(output, context);
1238
+ return de_CommandError(output, context);
1547
1239
  }
1548
1240
  const data = await parseBody(output.body, context);
1549
1241
  let contents = {};
@@ -1554,31 +1246,9 @@ var de_CreateTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
1554
1246
  };
1555
1247
  return response;
1556
1248
  }, "de_CreateTaskCommand");
1557
- var de_CreateTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
1558
- const parsedOutput = {
1559
- ...output,
1560
- body: await parseErrorBody(output.body, context)
1561
- };
1562
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1563
- switch (errorCode) {
1564
- case "InternalException":
1565
- case "com.amazonaws.datasync#InternalException":
1566
- throw await de_InternalExceptionRes(parsedOutput, context);
1567
- case "InvalidRequestException":
1568
- case "com.amazonaws.datasync#InvalidRequestException":
1569
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1570
- default:
1571
- const parsedBody = parsedOutput.body;
1572
- return throwDefaultError({
1573
- output,
1574
- parsedBody,
1575
- errorCode
1576
- });
1577
- }
1578
- }, "de_CreateTaskCommandError");
1579
1249
  var de_DeleteAgentCommand = /* @__PURE__ */ __name(async (output, context) => {
1580
1250
  if (output.statusCode >= 300) {
1581
- return de_DeleteAgentCommandError(output, context);
1251
+ return de_CommandError(output, context);
1582
1252
  }
1583
1253
  const data = await parseBody(output.body, context);
1584
1254
  let contents = {};
@@ -1589,31 +1259,9 @@ var de_DeleteAgentCommand = /* @__PURE__ */ __name(async (output, context) => {
1589
1259
  };
1590
1260
  return response;
1591
1261
  }, "de_DeleteAgentCommand");
1592
- var de_DeleteAgentCommandError = /* @__PURE__ */ __name(async (output, context) => {
1593
- const parsedOutput = {
1594
- ...output,
1595
- body: await parseErrorBody(output.body, context)
1596
- };
1597
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1598
- switch (errorCode) {
1599
- case "InternalException":
1600
- case "com.amazonaws.datasync#InternalException":
1601
- throw await de_InternalExceptionRes(parsedOutput, context);
1602
- case "InvalidRequestException":
1603
- case "com.amazonaws.datasync#InvalidRequestException":
1604
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1605
- default:
1606
- const parsedBody = parsedOutput.body;
1607
- return throwDefaultError({
1608
- output,
1609
- parsedBody,
1610
- errorCode
1611
- });
1612
- }
1613
- }, "de_DeleteAgentCommandError");
1614
1262
  var de_DeleteLocationCommand = /* @__PURE__ */ __name(async (output, context) => {
1615
1263
  if (output.statusCode >= 300) {
1616
- return de_DeleteLocationCommandError(output, context);
1264
+ return de_CommandError(output, context);
1617
1265
  }
1618
1266
  const data = await parseBody(output.body, context);
1619
1267
  let contents = {};
@@ -1624,31 +1272,9 @@ var de_DeleteLocationCommand = /* @__PURE__ */ __name(async (output, context) =>
1624
1272
  };
1625
1273
  return response;
1626
1274
  }, "de_DeleteLocationCommand");
1627
- var de_DeleteLocationCommandError = /* @__PURE__ */ __name(async (output, context) => {
1628
- const parsedOutput = {
1629
- ...output,
1630
- body: await parseErrorBody(output.body, context)
1631
- };
1632
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1633
- switch (errorCode) {
1634
- case "InternalException":
1635
- case "com.amazonaws.datasync#InternalException":
1636
- throw await de_InternalExceptionRes(parsedOutput, context);
1637
- case "InvalidRequestException":
1638
- case "com.amazonaws.datasync#InvalidRequestException":
1639
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1640
- default:
1641
- const parsedBody = parsedOutput.body;
1642
- return throwDefaultError({
1643
- output,
1644
- parsedBody,
1645
- errorCode
1646
- });
1647
- }
1648
- }, "de_DeleteLocationCommandError");
1649
1275
  var de_DeleteTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
1650
1276
  if (output.statusCode >= 300) {
1651
- return de_DeleteTaskCommandError(output, context);
1277
+ return de_CommandError(output, context);
1652
1278
  }
1653
1279
  const data = await parseBody(output.body, context);
1654
1280
  let contents = {};
@@ -1659,31 +1285,9 @@ var de_DeleteTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
1659
1285
  };
1660
1286
  return response;
1661
1287
  }, "de_DeleteTaskCommand");
1662
- var de_DeleteTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
1663
- const parsedOutput = {
1664
- ...output,
1665
- body: await parseErrorBody(output.body, context)
1666
- };
1667
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1668
- switch (errorCode) {
1669
- case "InternalException":
1670
- case "com.amazonaws.datasync#InternalException":
1671
- throw await de_InternalExceptionRes(parsedOutput, context);
1672
- case "InvalidRequestException":
1673
- case "com.amazonaws.datasync#InvalidRequestException":
1674
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1675
- default:
1676
- const parsedBody = parsedOutput.body;
1677
- return throwDefaultError({
1678
- output,
1679
- parsedBody,
1680
- errorCode
1681
- });
1682
- }
1683
- }, "de_DeleteTaskCommandError");
1684
1288
  var de_DescribeAgentCommand = /* @__PURE__ */ __name(async (output, context) => {
1685
1289
  if (output.statusCode >= 300) {
1686
- return de_DescribeAgentCommandError(output, context);
1290
+ return de_CommandError(output, context);
1687
1291
  }
1688
1292
  const data = await parseBody(output.body, context);
1689
1293
  let contents = {};
@@ -1694,31 +1298,9 @@ var de_DescribeAgentCommand = /* @__PURE__ */ __name(async (output, context) =>
1694
1298
  };
1695
1299
  return response;
1696
1300
  }, "de_DescribeAgentCommand");
1697
- var de_DescribeAgentCommandError = /* @__PURE__ */ __name(async (output, context) => {
1698
- const parsedOutput = {
1699
- ...output,
1700
- body: await parseErrorBody(output.body, context)
1701
- };
1702
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1703
- switch (errorCode) {
1704
- case "InternalException":
1705
- case "com.amazonaws.datasync#InternalException":
1706
- throw await de_InternalExceptionRes(parsedOutput, context);
1707
- case "InvalidRequestException":
1708
- case "com.amazonaws.datasync#InvalidRequestException":
1709
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1710
- default:
1711
- const parsedBody = parsedOutput.body;
1712
- return throwDefaultError({
1713
- output,
1714
- parsedBody,
1715
- errorCode
1716
- });
1717
- }
1718
- }, "de_DescribeAgentCommandError");
1719
1301
  var de_DescribeDiscoveryJobCommand = /* @__PURE__ */ __name(async (output, context) => {
1720
1302
  if (output.statusCode >= 300) {
1721
- return de_DescribeDiscoveryJobCommandError(output, context);
1303
+ return de_CommandError(output, context);
1722
1304
  }
1723
1305
  const data = await parseBody(output.body, context);
1724
1306
  let contents = {};
@@ -1729,31 +1311,9 @@ var de_DescribeDiscoveryJobCommand = /* @__PURE__ */ __name(async (output, conte
1729
1311
  };
1730
1312
  return response;
1731
1313
  }, "de_DescribeDiscoveryJobCommand");
1732
- var de_DescribeDiscoveryJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
1733
- const parsedOutput = {
1734
- ...output,
1735
- body: await parseErrorBody(output.body, context)
1736
- };
1737
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1738
- switch (errorCode) {
1739
- case "InternalException":
1740
- case "com.amazonaws.datasync#InternalException":
1741
- throw await de_InternalExceptionRes(parsedOutput, context);
1742
- case "InvalidRequestException":
1743
- case "com.amazonaws.datasync#InvalidRequestException":
1744
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1745
- default:
1746
- const parsedBody = parsedOutput.body;
1747
- return throwDefaultError({
1748
- output,
1749
- parsedBody,
1750
- errorCode
1751
- });
1752
- }
1753
- }, "de_DescribeDiscoveryJobCommandError");
1754
1314
  var de_DescribeLocationAzureBlobCommand = /* @__PURE__ */ __name(async (output, context) => {
1755
1315
  if (output.statusCode >= 300) {
1756
- return de_DescribeLocationAzureBlobCommandError(output, context);
1316
+ return de_CommandError(output, context);
1757
1317
  }
1758
1318
  const data = await parseBody(output.body, context);
1759
1319
  let contents = {};
@@ -1764,31 +1324,9 @@ var de_DescribeLocationAzureBlobCommand = /* @__PURE__ */ __name(async (output,
1764
1324
  };
1765
1325
  return response;
1766
1326
  }, "de_DescribeLocationAzureBlobCommand");
1767
- var de_DescribeLocationAzureBlobCommandError = /* @__PURE__ */ __name(async (output, context) => {
1768
- const parsedOutput = {
1769
- ...output,
1770
- body: await parseErrorBody(output.body, context)
1771
- };
1772
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1773
- switch (errorCode) {
1774
- case "InternalException":
1775
- case "com.amazonaws.datasync#InternalException":
1776
- throw await de_InternalExceptionRes(parsedOutput, context);
1777
- case "InvalidRequestException":
1778
- case "com.amazonaws.datasync#InvalidRequestException":
1779
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1780
- default:
1781
- const parsedBody = parsedOutput.body;
1782
- return throwDefaultError({
1783
- output,
1784
- parsedBody,
1785
- errorCode
1786
- });
1787
- }
1788
- }, "de_DescribeLocationAzureBlobCommandError");
1789
1327
  var de_DescribeLocationEfsCommand = /* @__PURE__ */ __name(async (output, context) => {
1790
1328
  if (output.statusCode >= 300) {
1791
- return de_DescribeLocationEfsCommandError(output, context);
1329
+ return de_CommandError(output, context);
1792
1330
  }
1793
1331
  const data = await parseBody(output.body, context);
1794
1332
  let contents = {};
@@ -1799,31 +1337,9 @@ var de_DescribeLocationEfsCommand = /* @__PURE__ */ __name(async (output, contex
1799
1337
  };
1800
1338
  return response;
1801
1339
  }, "de_DescribeLocationEfsCommand");
1802
- var de_DescribeLocationEfsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1803
- const parsedOutput = {
1804
- ...output,
1805
- body: await parseErrorBody(output.body, context)
1806
- };
1807
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1808
- switch (errorCode) {
1809
- case "InternalException":
1810
- case "com.amazonaws.datasync#InternalException":
1811
- throw await de_InternalExceptionRes(parsedOutput, context);
1812
- case "InvalidRequestException":
1813
- case "com.amazonaws.datasync#InvalidRequestException":
1814
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1815
- default:
1816
- const parsedBody = parsedOutput.body;
1817
- return throwDefaultError({
1818
- output,
1819
- parsedBody,
1820
- errorCode
1821
- });
1822
- }
1823
- }, "de_DescribeLocationEfsCommandError");
1824
1340
  var de_DescribeLocationFsxLustreCommand = /* @__PURE__ */ __name(async (output, context) => {
1825
1341
  if (output.statusCode >= 300) {
1826
- return de_DescribeLocationFsxLustreCommandError(output, context);
1342
+ return de_CommandError(output, context);
1827
1343
  }
1828
1344
  const data = await parseBody(output.body, context);
1829
1345
  let contents = {};
@@ -1834,31 +1350,9 @@ var de_DescribeLocationFsxLustreCommand = /* @__PURE__ */ __name(async (output,
1834
1350
  };
1835
1351
  return response;
1836
1352
  }, "de_DescribeLocationFsxLustreCommand");
1837
- var de_DescribeLocationFsxLustreCommandError = /* @__PURE__ */ __name(async (output, context) => {
1838
- const parsedOutput = {
1839
- ...output,
1840
- body: await parseErrorBody(output.body, context)
1841
- };
1842
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1843
- switch (errorCode) {
1844
- case "InternalException":
1845
- case "com.amazonaws.datasync#InternalException":
1846
- throw await de_InternalExceptionRes(parsedOutput, context);
1847
- case "InvalidRequestException":
1848
- case "com.amazonaws.datasync#InvalidRequestException":
1849
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1850
- default:
1851
- const parsedBody = parsedOutput.body;
1852
- return throwDefaultError({
1853
- output,
1854
- parsedBody,
1855
- errorCode
1856
- });
1857
- }
1858
- }, "de_DescribeLocationFsxLustreCommandError");
1859
1353
  var de_DescribeLocationFsxOntapCommand = /* @__PURE__ */ __name(async (output, context) => {
1860
1354
  if (output.statusCode >= 300) {
1861
- return de_DescribeLocationFsxOntapCommandError(output, context);
1355
+ return de_CommandError(output, context);
1862
1356
  }
1863
1357
  const data = await parseBody(output.body, context);
1864
1358
  let contents = {};
@@ -1869,31 +1363,9 @@ var de_DescribeLocationFsxOntapCommand = /* @__PURE__ */ __name(async (output, c
1869
1363
  };
1870
1364
  return response;
1871
1365
  }, "de_DescribeLocationFsxOntapCommand");
1872
- var de_DescribeLocationFsxOntapCommandError = /* @__PURE__ */ __name(async (output, context) => {
1873
- const parsedOutput = {
1874
- ...output,
1875
- body: await parseErrorBody(output.body, context)
1876
- };
1877
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1878
- switch (errorCode) {
1879
- case "InternalException":
1880
- case "com.amazonaws.datasync#InternalException":
1881
- throw await de_InternalExceptionRes(parsedOutput, context);
1882
- case "InvalidRequestException":
1883
- case "com.amazonaws.datasync#InvalidRequestException":
1884
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1885
- default:
1886
- const parsedBody = parsedOutput.body;
1887
- return throwDefaultError({
1888
- output,
1889
- parsedBody,
1890
- errorCode
1891
- });
1892
- }
1893
- }, "de_DescribeLocationFsxOntapCommandError");
1894
1366
  var de_DescribeLocationFsxOpenZfsCommand = /* @__PURE__ */ __name(async (output, context) => {
1895
1367
  if (output.statusCode >= 300) {
1896
- return de_DescribeLocationFsxOpenZfsCommandError(output, context);
1368
+ return de_CommandError(output, context);
1897
1369
  }
1898
1370
  const data = await parseBody(output.body, context);
1899
1371
  let contents = {};
@@ -1904,66 +1376,22 @@ var de_DescribeLocationFsxOpenZfsCommand = /* @__PURE__ */ __name(async (output,
1904
1376
  };
1905
1377
  return response;
1906
1378
  }, "de_DescribeLocationFsxOpenZfsCommand");
1907
- var de_DescribeLocationFsxOpenZfsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1908
- const parsedOutput = {
1909
- ...output,
1910
- body: await parseErrorBody(output.body, context)
1911
- };
1912
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1913
- switch (errorCode) {
1914
- case "InternalException":
1915
- case "com.amazonaws.datasync#InternalException":
1916
- throw await de_InternalExceptionRes(parsedOutput, context);
1917
- case "InvalidRequestException":
1918
- case "com.amazonaws.datasync#InvalidRequestException":
1919
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1920
- default:
1921
- const parsedBody = parsedOutput.body;
1922
- return throwDefaultError({
1923
- output,
1924
- parsedBody,
1925
- errorCode
1926
- });
1927
- }
1928
- }, "de_DescribeLocationFsxOpenZfsCommandError");
1929
- var de_DescribeLocationFsxWindowsCommand = /* @__PURE__ */ __name(async (output, context) => {
1930
- if (output.statusCode >= 300) {
1931
- return de_DescribeLocationFsxWindowsCommandError(output, context);
1932
- }
1933
- const data = await parseBody(output.body, context);
1934
- let contents = {};
1935
- contents = de_DescribeLocationFsxWindowsResponse(data, context);
1936
- const response = {
1937
- $metadata: deserializeMetadata(output),
1938
- ...contents
1379
+ var de_DescribeLocationFsxWindowsCommand = /* @__PURE__ */ __name(async (output, context) => {
1380
+ if (output.statusCode >= 300) {
1381
+ return de_CommandError(output, context);
1382
+ }
1383
+ const data = await parseBody(output.body, context);
1384
+ let contents = {};
1385
+ contents = de_DescribeLocationFsxWindowsResponse(data, context);
1386
+ const response = {
1387
+ $metadata: deserializeMetadata(output),
1388
+ ...contents
1939
1389
  };
1940
1390
  return response;
1941
1391
  }, "de_DescribeLocationFsxWindowsCommand");
1942
- var de_DescribeLocationFsxWindowsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1943
- const parsedOutput = {
1944
- ...output,
1945
- body: await parseErrorBody(output.body, context)
1946
- };
1947
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1948
- switch (errorCode) {
1949
- case "InternalException":
1950
- case "com.amazonaws.datasync#InternalException":
1951
- throw await de_InternalExceptionRes(parsedOutput, context);
1952
- case "InvalidRequestException":
1953
- case "com.amazonaws.datasync#InvalidRequestException":
1954
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1955
- default:
1956
- const parsedBody = parsedOutput.body;
1957
- return throwDefaultError({
1958
- output,
1959
- parsedBody,
1960
- errorCode
1961
- });
1962
- }
1963
- }, "de_DescribeLocationFsxWindowsCommandError");
1964
1392
  var de_DescribeLocationHdfsCommand = /* @__PURE__ */ __name(async (output, context) => {
1965
1393
  if (output.statusCode >= 300) {
1966
- return de_DescribeLocationHdfsCommandError(output, context);
1394
+ return de_CommandError(output, context);
1967
1395
  }
1968
1396
  const data = await parseBody(output.body, context);
1969
1397
  let contents = {};
@@ -1974,31 +1402,9 @@ var de_DescribeLocationHdfsCommand = /* @__PURE__ */ __name(async (output, conte
1974
1402
  };
1975
1403
  return response;
1976
1404
  }, "de_DescribeLocationHdfsCommand");
1977
- var de_DescribeLocationHdfsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1978
- const parsedOutput = {
1979
- ...output,
1980
- body: await parseErrorBody(output.body, context)
1981
- };
1982
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1983
- switch (errorCode) {
1984
- case "InternalException":
1985
- case "com.amazonaws.datasync#InternalException":
1986
- throw await de_InternalExceptionRes(parsedOutput, context);
1987
- case "InvalidRequestException":
1988
- case "com.amazonaws.datasync#InvalidRequestException":
1989
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
1990
- default:
1991
- const parsedBody = parsedOutput.body;
1992
- return throwDefaultError({
1993
- output,
1994
- parsedBody,
1995
- errorCode
1996
- });
1997
- }
1998
- }, "de_DescribeLocationHdfsCommandError");
1999
1405
  var de_DescribeLocationNfsCommand = /* @__PURE__ */ __name(async (output, context) => {
2000
1406
  if (output.statusCode >= 300) {
2001
- return de_DescribeLocationNfsCommandError(output, context);
1407
+ return de_CommandError(output, context);
2002
1408
  }
2003
1409
  const data = await parseBody(output.body, context);
2004
1410
  let contents = {};
@@ -2009,31 +1415,9 @@ var de_DescribeLocationNfsCommand = /* @__PURE__ */ __name(async (output, contex
2009
1415
  };
2010
1416
  return response;
2011
1417
  }, "de_DescribeLocationNfsCommand");
2012
- var de_DescribeLocationNfsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2013
- const parsedOutput = {
2014
- ...output,
2015
- body: await parseErrorBody(output.body, context)
2016
- };
2017
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2018
- switch (errorCode) {
2019
- case "InternalException":
2020
- case "com.amazonaws.datasync#InternalException":
2021
- throw await de_InternalExceptionRes(parsedOutput, context);
2022
- case "InvalidRequestException":
2023
- case "com.amazonaws.datasync#InvalidRequestException":
2024
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2025
- default:
2026
- const parsedBody = parsedOutput.body;
2027
- return throwDefaultError({
2028
- output,
2029
- parsedBody,
2030
- errorCode
2031
- });
2032
- }
2033
- }, "de_DescribeLocationNfsCommandError");
2034
1418
  var de_DescribeLocationObjectStorageCommand = /* @__PURE__ */ __name(async (output, context) => {
2035
1419
  if (output.statusCode >= 300) {
2036
- return de_DescribeLocationObjectStorageCommandError(output, context);
1420
+ return de_CommandError(output, context);
2037
1421
  }
2038
1422
  const data = await parseBody(output.body, context);
2039
1423
  let contents = {};
@@ -2044,31 +1428,9 @@ var de_DescribeLocationObjectStorageCommand = /* @__PURE__ */ __name(async (outp
2044
1428
  };
2045
1429
  return response;
2046
1430
  }, "de_DescribeLocationObjectStorageCommand");
2047
- var de_DescribeLocationObjectStorageCommandError = /* @__PURE__ */ __name(async (output, context) => {
2048
- const parsedOutput = {
2049
- ...output,
2050
- body: await parseErrorBody(output.body, context)
2051
- };
2052
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2053
- switch (errorCode) {
2054
- case "InternalException":
2055
- case "com.amazonaws.datasync#InternalException":
2056
- throw await de_InternalExceptionRes(parsedOutput, context);
2057
- case "InvalidRequestException":
2058
- case "com.amazonaws.datasync#InvalidRequestException":
2059
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2060
- default:
2061
- const parsedBody = parsedOutput.body;
2062
- return throwDefaultError({
2063
- output,
2064
- parsedBody,
2065
- errorCode
2066
- });
2067
- }
2068
- }, "de_DescribeLocationObjectStorageCommandError");
2069
1431
  var de_DescribeLocationS3Command = /* @__PURE__ */ __name(async (output, context) => {
2070
1432
  if (output.statusCode >= 300) {
2071
- return de_DescribeLocationS3CommandError(output, context);
1433
+ return de_CommandError(output, context);
2072
1434
  }
2073
1435
  const data = await parseBody(output.body, context);
2074
1436
  let contents = {};
@@ -2079,31 +1441,9 @@ var de_DescribeLocationS3Command = /* @__PURE__ */ __name(async (output, context
2079
1441
  };
2080
1442
  return response;
2081
1443
  }, "de_DescribeLocationS3Command");
2082
- var de_DescribeLocationS3CommandError = /* @__PURE__ */ __name(async (output, context) => {
2083
- const parsedOutput = {
2084
- ...output,
2085
- body: await parseErrorBody(output.body, context)
2086
- };
2087
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2088
- switch (errorCode) {
2089
- case "InternalException":
2090
- case "com.amazonaws.datasync#InternalException":
2091
- throw await de_InternalExceptionRes(parsedOutput, context);
2092
- case "InvalidRequestException":
2093
- case "com.amazonaws.datasync#InvalidRequestException":
2094
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2095
- default:
2096
- const parsedBody = parsedOutput.body;
2097
- return throwDefaultError({
2098
- output,
2099
- parsedBody,
2100
- errorCode
2101
- });
2102
- }
2103
- }, "de_DescribeLocationS3CommandError");
2104
1444
  var de_DescribeLocationSmbCommand = /* @__PURE__ */ __name(async (output, context) => {
2105
1445
  if (output.statusCode >= 300) {
2106
- return de_DescribeLocationSmbCommandError(output, context);
1446
+ return de_CommandError(output, context);
2107
1447
  }
2108
1448
  const data = await parseBody(output.body, context);
2109
1449
  let contents = {};
@@ -2114,31 +1454,9 @@ var de_DescribeLocationSmbCommand = /* @__PURE__ */ __name(async (output, contex
2114
1454
  };
2115
1455
  return response;
2116
1456
  }, "de_DescribeLocationSmbCommand");
2117
- var de_DescribeLocationSmbCommandError = /* @__PURE__ */ __name(async (output, context) => {
2118
- const parsedOutput = {
2119
- ...output,
2120
- body: await parseErrorBody(output.body, context)
2121
- };
2122
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2123
- switch (errorCode) {
2124
- case "InternalException":
2125
- case "com.amazonaws.datasync#InternalException":
2126
- throw await de_InternalExceptionRes(parsedOutput, context);
2127
- case "InvalidRequestException":
2128
- case "com.amazonaws.datasync#InvalidRequestException":
2129
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2130
- default:
2131
- const parsedBody = parsedOutput.body;
2132
- return throwDefaultError({
2133
- output,
2134
- parsedBody,
2135
- errorCode
2136
- });
2137
- }
2138
- }, "de_DescribeLocationSmbCommandError");
2139
1457
  var de_DescribeStorageSystemCommand = /* @__PURE__ */ __name(async (output, context) => {
2140
1458
  if (output.statusCode >= 300) {
2141
- return de_DescribeStorageSystemCommandError(output, context);
1459
+ return de_CommandError(output, context);
2142
1460
  }
2143
1461
  const data = await parseBody(output.body, context);
2144
1462
  let contents = {};
@@ -2149,31 +1467,9 @@ var de_DescribeStorageSystemCommand = /* @__PURE__ */ __name(async (output, cont
2149
1467
  };
2150
1468
  return response;
2151
1469
  }, "de_DescribeStorageSystemCommand");
2152
- var de_DescribeStorageSystemCommandError = /* @__PURE__ */ __name(async (output, context) => {
2153
- const parsedOutput = {
2154
- ...output,
2155
- body: await parseErrorBody(output.body, context)
2156
- };
2157
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2158
- switch (errorCode) {
2159
- case "InternalException":
2160
- case "com.amazonaws.datasync#InternalException":
2161
- throw await de_InternalExceptionRes(parsedOutput, context);
2162
- case "InvalidRequestException":
2163
- case "com.amazonaws.datasync#InvalidRequestException":
2164
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2165
- default:
2166
- const parsedBody = parsedOutput.body;
2167
- return throwDefaultError({
2168
- output,
2169
- parsedBody,
2170
- errorCode
2171
- });
2172
- }
2173
- }, "de_DescribeStorageSystemCommandError");
2174
1470
  var de_DescribeStorageSystemResourceMetricsCommand = /* @__PURE__ */ __name(async (output, context) => {
2175
1471
  if (output.statusCode >= 300) {
2176
- return de_DescribeStorageSystemResourceMetricsCommandError(output, context);
1472
+ return de_CommandError(output, context);
2177
1473
  }
2178
1474
  const data = await parseBody(output.body, context);
2179
1475
  let contents = {};
@@ -2184,31 +1480,9 @@ var de_DescribeStorageSystemResourceMetricsCommand = /* @__PURE__ */ __name(asyn
2184
1480
  };
2185
1481
  return response;
2186
1482
  }, "de_DescribeStorageSystemResourceMetricsCommand");
2187
- var de_DescribeStorageSystemResourceMetricsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2188
- const parsedOutput = {
2189
- ...output,
2190
- body: await parseErrorBody(output.body, context)
2191
- };
2192
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2193
- switch (errorCode) {
2194
- case "InternalException":
2195
- case "com.amazonaws.datasync#InternalException":
2196
- throw await de_InternalExceptionRes(parsedOutput, context);
2197
- case "InvalidRequestException":
2198
- case "com.amazonaws.datasync#InvalidRequestException":
2199
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2200
- default:
2201
- const parsedBody = parsedOutput.body;
2202
- return throwDefaultError({
2203
- output,
2204
- parsedBody,
2205
- errorCode
2206
- });
2207
- }
2208
- }, "de_DescribeStorageSystemResourceMetricsCommandError");
2209
1483
  var de_DescribeStorageSystemResourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
2210
1484
  if (output.statusCode >= 300) {
2211
- return de_DescribeStorageSystemResourcesCommandError(output, context);
1485
+ return de_CommandError(output, context);
2212
1486
  }
2213
1487
  const data = await parseBody(output.body, context);
2214
1488
  let contents = {};
@@ -2219,31 +1493,9 @@ var de_DescribeStorageSystemResourcesCommand = /* @__PURE__ */ __name(async (out
2219
1493
  };
2220
1494
  return response;
2221
1495
  }, "de_DescribeStorageSystemResourcesCommand");
2222
- var de_DescribeStorageSystemResourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2223
- const parsedOutput = {
2224
- ...output,
2225
- body: await parseErrorBody(output.body, context)
2226
- };
2227
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2228
- switch (errorCode) {
2229
- case "InternalException":
2230
- case "com.amazonaws.datasync#InternalException":
2231
- throw await de_InternalExceptionRes(parsedOutput, context);
2232
- case "InvalidRequestException":
2233
- case "com.amazonaws.datasync#InvalidRequestException":
2234
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2235
- default:
2236
- const parsedBody = parsedOutput.body;
2237
- return throwDefaultError({
2238
- output,
2239
- parsedBody,
2240
- errorCode
2241
- });
2242
- }
2243
- }, "de_DescribeStorageSystemResourcesCommandError");
2244
1496
  var de_DescribeTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
2245
1497
  if (output.statusCode >= 300) {
2246
- return de_DescribeTaskCommandError(output, context);
1498
+ return de_CommandError(output, context);
2247
1499
  }
2248
1500
  const data = await parseBody(output.body, context);
2249
1501
  let contents = {};
@@ -2254,31 +1506,9 @@ var de_DescribeTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
2254
1506
  };
2255
1507
  return response;
2256
1508
  }, "de_DescribeTaskCommand");
2257
- var de_DescribeTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
2258
- const parsedOutput = {
2259
- ...output,
2260
- body: await parseErrorBody(output.body, context)
2261
- };
2262
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2263
- switch (errorCode) {
2264
- case "InternalException":
2265
- case "com.amazonaws.datasync#InternalException":
2266
- throw await de_InternalExceptionRes(parsedOutput, context);
2267
- case "InvalidRequestException":
2268
- case "com.amazonaws.datasync#InvalidRequestException":
2269
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2270
- default:
2271
- const parsedBody = parsedOutput.body;
2272
- return throwDefaultError({
2273
- output,
2274
- parsedBody,
2275
- errorCode
2276
- });
2277
- }
2278
- }, "de_DescribeTaskCommandError");
2279
1509
  var de_DescribeTaskExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
2280
1510
  if (output.statusCode >= 300) {
2281
- return de_DescribeTaskExecutionCommandError(output, context);
1511
+ return de_CommandError(output, context);
2282
1512
  }
2283
1513
  const data = await parseBody(output.body, context);
2284
1514
  let contents = {};
@@ -2289,31 +1519,9 @@ var de_DescribeTaskExecutionCommand = /* @__PURE__ */ __name(async (output, cont
2289
1519
  };
2290
1520
  return response;
2291
1521
  }, "de_DescribeTaskExecutionCommand");
2292
- var de_DescribeTaskExecutionCommandError = /* @__PURE__ */ __name(async (output, context) => {
2293
- const parsedOutput = {
2294
- ...output,
2295
- body: await parseErrorBody(output.body, context)
2296
- };
2297
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2298
- switch (errorCode) {
2299
- case "InternalException":
2300
- case "com.amazonaws.datasync#InternalException":
2301
- throw await de_InternalExceptionRes(parsedOutput, context);
2302
- case "InvalidRequestException":
2303
- case "com.amazonaws.datasync#InvalidRequestException":
2304
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2305
- default:
2306
- const parsedBody = parsedOutput.body;
2307
- return throwDefaultError({
2308
- output,
2309
- parsedBody,
2310
- errorCode
2311
- });
2312
- }
2313
- }, "de_DescribeTaskExecutionCommandError");
2314
1522
  var de_GenerateRecommendationsCommand = /* @__PURE__ */ __name(async (output, context) => {
2315
1523
  if (output.statusCode >= 300) {
2316
- return de_GenerateRecommendationsCommandError(output, context);
1524
+ return de_CommandError(output, context);
2317
1525
  }
2318
1526
  const data = await parseBody(output.body, context);
2319
1527
  let contents = {};
@@ -2324,31 +1532,9 @@ var de_GenerateRecommendationsCommand = /* @__PURE__ */ __name(async (output, co
2324
1532
  };
2325
1533
  return response;
2326
1534
  }, "de_GenerateRecommendationsCommand");
2327
- var de_GenerateRecommendationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2328
- const parsedOutput = {
2329
- ...output,
2330
- body: await parseErrorBody(output.body, context)
2331
- };
2332
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2333
- switch (errorCode) {
2334
- case "InternalException":
2335
- case "com.amazonaws.datasync#InternalException":
2336
- throw await de_InternalExceptionRes(parsedOutput, context);
2337
- case "InvalidRequestException":
2338
- case "com.amazonaws.datasync#InvalidRequestException":
2339
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2340
- default:
2341
- const parsedBody = parsedOutput.body;
2342
- return throwDefaultError({
2343
- output,
2344
- parsedBody,
2345
- errorCode
2346
- });
2347
- }
2348
- }, "de_GenerateRecommendationsCommandError");
2349
1535
  var de_ListAgentsCommand = /* @__PURE__ */ __name(async (output, context) => {
2350
1536
  if (output.statusCode >= 300) {
2351
- return de_ListAgentsCommandError(output, context);
1537
+ return de_CommandError(output, context);
2352
1538
  }
2353
1539
  const data = await parseBody(output.body, context);
2354
1540
  let contents = {};
@@ -2359,31 +1545,9 @@ var de_ListAgentsCommand = /* @__PURE__ */ __name(async (output, context) => {
2359
1545
  };
2360
1546
  return response;
2361
1547
  }, "de_ListAgentsCommand");
2362
- var de_ListAgentsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2363
- const parsedOutput = {
2364
- ...output,
2365
- body: await parseErrorBody(output.body, context)
2366
- };
2367
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2368
- switch (errorCode) {
2369
- case "InternalException":
2370
- case "com.amazonaws.datasync#InternalException":
2371
- throw await de_InternalExceptionRes(parsedOutput, context);
2372
- case "InvalidRequestException":
2373
- case "com.amazonaws.datasync#InvalidRequestException":
2374
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2375
- default:
2376
- const parsedBody = parsedOutput.body;
2377
- return throwDefaultError({
2378
- output,
2379
- parsedBody,
2380
- errorCode
2381
- });
2382
- }
2383
- }, "de_ListAgentsCommandError");
2384
1548
  var de_ListDiscoveryJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
2385
1549
  if (output.statusCode >= 300) {
2386
- return de_ListDiscoveryJobsCommandError(output, context);
1550
+ return de_CommandError(output, context);
2387
1551
  }
2388
1552
  const data = await parseBody(output.body, context);
2389
1553
  let contents = {};
@@ -2394,31 +1558,9 @@ var de_ListDiscoveryJobsCommand = /* @__PURE__ */ __name(async (output, context)
2394
1558
  };
2395
1559
  return response;
2396
1560
  }, "de_ListDiscoveryJobsCommand");
2397
- var de_ListDiscoveryJobsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2398
- const parsedOutput = {
2399
- ...output,
2400
- body: await parseErrorBody(output.body, context)
2401
- };
2402
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2403
- switch (errorCode) {
2404
- case "InternalException":
2405
- case "com.amazonaws.datasync#InternalException":
2406
- throw await de_InternalExceptionRes(parsedOutput, context);
2407
- case "InvalidRequestException":
2408
- case "com.amazonaws.datasync#InvalidRequestException":
2409
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2410
- default:
2411
- const parsedBody = parsedOutput.body;
2412
- return throwDefaultError({
2413
- output,
2414
- parsedBody,
2415
- errorCode
2416
- });
2417
- }
2418
- }, "de_ListDiscoveryJobsCommandError");
2419
1561
  var de_ListLocationsCommand = /* @__PURE__ */ __name(async (output, context) => {
2420
1562
  if (output.statusCode >= 300) {
2421
- return de_ListLocationsCommandError(output, context);
1563
+ return de_CommandError(output, context);
2422
1564
  }
2423
1565
  const data = await parseBody(output.body, context);
2424
1566
  let contents = {};
@@ -2429,31 +1571,9 @@ var de_ListLocationsCommand = /* @__PURE__ */ __name(async (output, context) =>
2429
1571
  };
2430
1572
  return response;
2431
1573
  }, "de_ListLocationsCommand");
2432
- var de_ListLocationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2433
- const parsedOutput = {
2434
- ...output,
2435
- body: await parseErrorBody(output.body, context)
2436
- };
2437
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2438
- switch (errorCode) {
2439
- case "InternalException":
2440
- case "com.amazonaws.datasync#InternalException":
2441
- throw await de_InternalExceptionRes(parsedOutput, context);
2442
- case "InvalidRequestException":
2443
- case "com.amazonaws.datasync#InvalidRequestException":
2444
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2445
- default:
2446
- const parsedBody = parsedOutput.body;
2447
- return throwDefaultError({
2448
- output,
2449
- parsedBody,
2450
- errorCode
2451
- });
2452
- }
2453
- }, "de_ListLocationsCommandError");
2454
1574
  var de_ListStorageSystemsCommand = /* @__PURE__ */ __name(async (output, context) => {
2455
1575
  if (output.statusCode >= 300) {
2456
- return de_ListStorageSystemsCommandError(output, context);
1576
+ return de_CommandError(output, context);
2457
1577
  }
2458
1578
  const data = await parseBody(output.body, context);
2459
1579
  let contents = {};
@@ -2464,31 +1584,9 @@ var de_ListStorageSystemsCommand = /* @__PURE__ */ __name(async (output, context
2464
1584
  };
2465
1585
  return response;
2466
1586
  }, "de_ListStorageSystemsCommand");
2467
- var de_ListStorageSystemsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2468
- const parsedOutput = {
2469
- ...output,
2470
- body: await parseErrorBody(output.body, context)
2471
- };
2472
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2473
- switch (errorCode) {
2474
- case "InternalException":
2475
- case "com.amazonaws.datasync#InternalException":
2476
- throw await de_InternalExceptionRes(parsedOutput, context);
2477
- case "InvalidRequestException":
2478
- case "com.amazonaws.datasync#InvalidRequestException":
2479
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2480
- default:
2481
- const parsedBody = parsedOutput.body;
2482
- return throwDefaultError({
2483
- output,
2484
- parsedBody,
2485
- errorCode
2486
- });
2487
- }
2488
- }, "de_ListStorageSystemsCommandError");
2489
1587
  var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
2490
1588
  if (output.statusCode >= 300) {
2491
- return de_ListTagsForResourceCommandError(output, context);
1589
+ return de_CommandError(output, context);
2492
1590
  }
2493
1591
  const data = await parseBody(output.body, context);
2494
1592
  let contents = {};
@@ -2499,31 +1597,9 @@ var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, contex
2499
1597
  };
2500
1598
  return response;
2501
1599
  }, "de_ListTagsForResourceCommand");
2502
- var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
2503
- const parsedOutput = {
2504
- ...output,
2505
- body: await parseErrorBody(output.body, context)
2506
- };
2507
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2508
- switch (errorCode) {
2509
- case "InternalException":
2510
- case "com.amazonaws.datasync#InternalException":
2511
- throw await de_InternalExceptionRes(parsedOutput, context);
2512
- case "InvalidRequestException":
2513
- case "com.amazonaws.datasync#InvalidRequestException":
2514
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2515
- default:
2516
- const parsedBody = parsedOutput.body;
2517
- return throwDefaultError({
2518
- output,
2519
- parsedBody,
2520
- errorCode
2521
- });
2522
- }
2523
- }, "de_ListTagsForResourceCommandError");
2524
1600
  var de_ListTaskExecutionsCommand = /* @__PURE__ */ __name(async (output, context) => {
2525
1601
  if (output.statusCode >= 300) {
2526
- return de_ListTaskExecutionsCommandError(output, context);
1602
+ return de_CommandError(output, context);
2527
1603
  }
2528
1604
  const data = await parseBody(output.body, context);
2529
1605
  let contents = {};
@@ -2534,31 +1610,9 @@ var de_ListTaskExecutionsCommand = /* @__PURE__ */ __name(async (output, context
2534
1610
  };
2535
1611
  return response;
2536
1612
  }, "de_ListTaskExecutionsCommand");
2537
- var de_ListTaskExecutionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2538
- const parsedOutput = {
2539
- ...output,
2540
- body: await parseErrorBody(output.body, context)
2541
- };
2542
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2543
- switch (errorCode) {
2544
- case "InternalException":
2545
- case "com.amazonaws.datasync#InternalException":
2546
- throw await de_InternalExceptionRes(parsedOutput, context);
2547
- case "InvalidRequestException":
2548
- case "com.amazonaws.datasync#InvalidRequestException":
2549
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2550
- default:
2551
- const parsedBody = parsedOutput.body;
2552
- return throwDefaultError({
2553
- output,
2554
- parsedBody,
2555
- errorCode
2556
- });
2557
- }
2558
- }, "de_ListTaskExecutionsCommandError");
2559
1613
  var de_ListTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
2560
1614
  if (output.statusCode >= 300) {
2561
- return de_ListTasksCommandError(output, context);
1615
+ return de_CommandError(output, context);
2562
1616
  }
2563
1617
  const data = await parseBody(output.body, context);
2564
1618
  let contents = {};
@@ -2569,31 +1623,9 @@ var de_ListTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
2569
1623
  };
2570
1624
  return response;
2571
1625
  }, "de_ListTasksCommand");
2572
- var de_ListTasksCommandError = /* @__PURE__ */ __name(async (output, context) => {
2573
- const parsedOutput = {
2574
- ...output,
2575
- body: await parseErrorBody(output.body, context)
2576
- };
2577
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2578
- switch (errorCode) {
2579
- case "InternalException":
2580
- case "com.amazonaws.datasync#InternalException":
2581
- throw await de_InternalExceptionRes(parsedOutput, context);
2582
- case "InvalidRequestException":
2583
- case "com.amazonaws.datasync#InvalidRequestException":
2584
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2585
- default:
2586
- const parsedBody = parsedOutput.body;
2587
- return throwDefaultError({
2588
- output,
2589
- parsedBody,
2590
- errorCode
2591
- });
2592
- }
2593
- }, "de_ListTasksCommandError");
2594
1626
  var de_RemoveStorageSystemCommand = /* @__PURE__ */ __name(async (output, context) => {
2595
1627
  if (output.statusCode >= 300) {
2596
- return de_RemoveStorageSystemCommandError(output, context);
1628
+ return de_CommandError(output, context);
2597
1629
  }
2598
1630
  const data = await parseBody(output.body, context);
2599
1631
  let contents = {};
@@ -2604,101 +1636,35 @@ var de_RemoveStorageSystemCommand = /* @__PURE__ */ __name(async (output, contex
2604
1636
  };
2605
1637
  return response;
2606
1638
  }, "de_RemoveStorageSystemCommand");
2607
- var de_RemoveStorageSystemCommandError = /* @__PURE__ */ __name(async (output, context) => {
2608
- const parsedOutput = {
2609
- ...output,
2610
- body: await parseErrorBody(output.body, context)
2611
- };
2612
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2613
- switch (errorCode) {
2614
- case "InternalException":
2615
- case "com.amazonaws.datasync#InternalException":
2616
- throw await de_InternalExceptionRes(parsedOutput, context);
2617
- case "InvalidRequestException":
2618
- case "com.amazonaws.datasync#InvalidRequestException":
2619
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2620
- default:
2621
- const parsedBody = parsedOutput.body;
2622
- return throwDefaultError({
2623
- output,
2624
- parsedBody,
2625
- errorCode
2626
- });
2627
- }
2628
- }, "de_RemoveStorageSystemCommandError");
2629
1639
  var de_StartDiscoveryJobCommand = /* @__PURE__ */ __name(async (output, context) => {
2630
1640
  if (output.statusCode >= 300) {
2631
- return de_StartDiscoveryJobCommandError(output, context);
2632
- }
2633
- const data = await parseBody(output.body, context);
2634
- let contents = {};
2635
- contents = (0, import_smithy_client._json)(data);
2636
- const response = {
2637
- $metadata: deserializeMetadata(output),
2638
- ...contents
2639
- };
2640
- return response;
2641
- }, "de_StartDiscoveryJobCommand");
2642
- var de_StartDiscoveryJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
2643
- const parsedOutput = {
2644
- ...output,
2645
- body: await parseErrorBody(output.body, context)
2646
- };
2647
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2648
- switch (errorCode) {
2649
- case "InternalException":
2650
- case "com.amazonaws.datasync#InternalException":
2651
- throw await de_InternalExceptionRes(parsedOutput, context);
2652
- case "InvalidRequestException":
2653
- case "com.amazonaws.datasync#InvalidRequestException":
2654
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2655
- default:
2656
- const parsedBody = parsedOutput.body;
2657
- return throwDefaultError({
2658
- output,
2659
- parsedBody,
2660
- errorCode
2661
- });
2662
- }
2663
- }, "de_StartDiscoveryJobCommandError");
2664
- var de_StartTaskExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
2665
- if (output.statusCode >= 300) {
2666
- return de_StartTaskExecutionCommandError(output, context);
1641
+ return de_CommandError(output, context);
2667
1642
  }
2668
1643
  const data = await parseBody(output.body, context);
2669
1644
  let contents = {};
2670
1645
  contents = (0, import_smithy_client._json)(data);
2671
1646
  const response = {
2672
- $metadata: deserializeMetadata(output),
2673
- ...contents
2674
- };
2675
- return response;
2676
- }, "de_StartTaskExecutionCommand");
2677
- var de_StartTaskExecutionCommandError = /* @__PURE__ */ __name(async (output, context) => {
2678
- const parsedOutput = {
2679
- ...output,
2680
- body: await parseErrorBody(output.body, context)
2681
- };
2682
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2683
- switch (errorCode) {
2684
- case "InternalException":
2685
- case "com.amazonaws.datasync#InternalException":
2686
- throw await de_InternalExceptionRes(parsedOutput, context);
2687
- case "InvalidRequestException":
2688
- case "com.amazonaws.datasync#InvalidRequestException":
2689
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2690
- default:
2691
- const parsedBody = parsedOutput.body;
2692
- return throwDefaultError({
2693
- output,
2694
- parsedBody,
2695
- errorCode
2696
- });
1647
+ $metadata: deserializeMetadata(output),
1648
+ ...contents
1649
+ };
1650
+ return response;
1651
+ }, "de_StartDiscoveryJobCommand");
1652
+ var de_StartTaskExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
1653
+ if (output.statusCode >= 300) {
1654
+ return de_CommandError(output, context);
2697
1655
  }
2698
- }, "de_StartTaskExecutionCommandError");
1656
+ const data = await parseBody(output.body, context);
1657
+ let contents = {};
1658
+ contents = (0, import_smithy_client._json)(data);
1659
+ const response = {
1660
+ $metadata: deserializeMetadata(output),
1661
+ ...contents
1662
+ };
1663
+ return response;
1664
+ }, "de_StartTaskExecutionCommand");
2699
1665
  var de_StopDiscoveryJobCommand = /* @__PURE__ */ __name(async (output, context) => {
2700
1666
  if (output.statusCode >= 300) {
2701
- return de_StopDiscoveryJobCommandError(output, context);
1667
+ return de_CommandError(output, context);
2702
1668
  }
2703
1669
  const data = await parseBody(output.body, context);
2704
1670
  let contents = {};
@@ -2709,31 +1675,9 @@ var de_StopDiscoveryJobCommand = /* @__PURE__ */ __name(async (output, context)
2709
1675
  };
2710
1676
  return response;
2711
1677
  }, "de_StopDiscoveryJobCommand");
2712
- var de_StopDiscoveryJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
2713
- const parsedOutput = {
2714
- ...output,
2715
- body: await parseErrorBody(output.body, context)
2716
- };
2717
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2718
- switch (errorCode) {
2719
- case "InternalException":
2720
- case "com.amazonaws.datasync#InternalException":
2721
- throw await de_InternalExceptionRes(parsedOutput, context);
2722
- case "InvalidRequestException":
2723
- case "com.amazonaws.datasync#InvalidRequestException":
2724
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2725
- default:
2726
- const parsedBody = parsedOutput.body;
2727
- return throwDefaultError({
2728
- output,
2729
- parsedBody,
2730
- errorCode
2731
- });
2732
- }
2733
- }, "de_StopDiscoveryJobCommandError");
2734
1678
  var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
2735
1679
  if (output.statusCode >= 300) {
2736
- return de_TagResourceCommandError(output, context);
1680
+ return de_CommandError(output, context);
2737
1681
  }
2738
1682
  const data = await parseBody(output.body, context);
2739
1683
  let contents = {};
@@ -2744,31 +1688,9 @@ var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
2744
1688
  };
2745
1689
  return response;
2746
1690
  }, "de_TagResourceCommand");
2747
- var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
2748
- const parsedOutput = {
2749
- ...output,
2750
- body: await parseErrorBody(output.body, context)
2751
- };
2752
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2753
- switch (errorCode) {
2754
- case "InternalException":
2755
- case "com.amazonaws.datasync#InternalException":
2756
- throw await de_InternalExceptionRes(parsedOutput, context);
2757
- case "InvalidRequestException":
2758
- case "com.amazonaws.datasync#InvalidRequestException":
2759
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2760
- default:
2761
- const parsedBody = parsedOutput.body;
2762
- return throwDefaultError({
2763
- output,
2764
- parsedBody,
2765
- errorCode
2766
- });
2767
- }
2768
- }, "de_TagResourceCommandError");
2769
1691
  var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
2770
1692
  if (output.statusCode >= 300) {
2771
- return de_UntagResourceCommandError(output, context);
1693
+ return de_CommandError(output, context);
2772
1694
  }
2773
1695
  const data = await parseBody(output.body, context);
2774
1696
  let contents = {};
@@ -2779,31 +1701,9 @@ var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) =>
2779
1701
  };
2780
1702
  return response;
2781
1703
  }, "de_UntagResourceCommand");
2782
- var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
2783
- const parsedOutput = {
2784
- ...output,
2785
- body: await parseErrorBody(output.body, context)
2786
- };
2787
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2788
- switch (errorCode) {
2789
- case "InternalException":
2790
- case "com.amazonaws.datasync#InternalException":
2791
- throw await de_InternalExceptionRes(parsedOutput, context);
2792
- case "InvalidRequestException":
2793
- case "com.amazonaws.datasync#InvalidRequestException":
2794
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2795
- default:
2796
- const parsedBody = parsedOutput.body;
2797
- return throwDefaultError({
2798
- output,
2799
- parsedBody,
2800
- errorCode
2801
- });
2802
- }
2803
- }, "de_UntagResourceCommandError");
2804
1704
  var de_UpdateAgentCommand = /* @__PURE__ */ __name(async (output, context) => {
2805
1705
  if (output.statusCode >= 300) {
2806
- return de_UpdateAgentCommandError(output, context);
1706
+ return de_CommandError(output, context);
2807
1707
  }
2808
1708
  const data = await parseBody(output.body, context);
2809
1709
  let contents = {};
@@ -2814,31 +1714,9 @@ var de_UpdateAgentCommand = /* @__PURE__ */ __name(async (output, context) => {
2814
1714
  };
2815
1715
  return response;
2816
1716
  }, "de_UpdateAgentCommand");
2817
- var de_UpdateAgentCommandError = /* @__PURE__ */ __name(async (output, context) => {
2818
- const parsedOutput = {
2819
- ...output,
2820
- body: await parseErrorBody(output.body, context)
2821
- };
2822
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2823
- switch (errorCode) {
2824
- case "InternalException":
2825
- case "com.amazonaws.datasync#InternalException":
2826
- throw await de_InternalExceptionRes(parsedOutput, context);
2827
- case "InvalidRequestException":
2828
- case "com.amazonaws.datasync#InvalidRequestException":
2829
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2830
- default:
2831
- const parsedBody = parsedOutput.body;
2832
- return throwDefaultError({
2833
- output,
2834
- parsedBody,
2835
- errorCode
2836
- });
2837
- }
2838
- }, "de_UpdateAgentCommandError");
2839
1717
  var de_UpdateDiscoveryJobCommand = /* @__PURE__ */ __name(async (output, context) => {
2840
1718
  if (output.statusCode >= 300) {
2841
- return de_UpdateDiscoveryJobCommandError(output, context);
1719
+ return de_CommandError(output, context);
2842
1720
  }
2843
1721
  const data = await parseBody(output.body, context);
2844
1722
  let contents = {};
@@ -2849,31 +1727,9 @@ var de_UpdateDiscoveryJobCommand = /* @__PURE__ */ __name(async (output, context
2849
1727
  };
2850
1728
  return response;
2851
1729
  }, "de_UpdateDiscoveryJobCommand");
2852
- var de_UpdateDiscoveryJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
2853
- const parsedOutput = {
2854
- ...output,
2855
- body: await parseErrorBody(output.body, context)
2856
- };
2857
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2858
- switch (errorCode) {
2859
- case "InternalException":
2860
- case "com.amazonaws.datasync#InternalException":
2861
- throw await de_InternalExceptionRes(parsedOutput, context);
2862
- case "InvalidRequestException":
2863
- case "com.amazonaws.datasync#InvalidRequestException":
2864
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2865
- default:
2866
- const parsedBody = parsedOutput.body;
2867
- return throwDefaultError({
2868
- output,
2869
- parsedBody,
2870
- errorCode
2871
- });
2872
- }
2873
- }, "de_UpdateDiscoveryJobCommandError");
2874
1730
  var de_UpdateLocationAzureBlobCommand = /* @__PURE__ */ __name(async (output, context) => {
2875
1731
  if (output.statusCode >= 300) {
2876
- return de_UpdateLocationAzureBlobCommandError(output, context);
1732
+ return de_CommandError(output, context);
2877
1733
  }
2878
1734
  const data = await parseBody(output.body, context);
2879
1735
  let contents = {};
@@ -2884,31 +1740,9 @@ var de_UpdateLocationAzureBlobCommand = /* @__PURE__ */ __name(async (output, co
2884
1740
  };
2885
1741
  return response;
2886
1742
  }, "de_UpdateLocationAzureBlobCommand");
2887
- var de_UpdateLocationAzureBlobCommandError = /* @__PURE__ */ __name(async (output, context) => {
2888
- const parsedOutput = {
2889
- ...output,
2890
- body: await parseErrorBody(output.body, context)
2891
- };
2892
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2893
- switch (errorCode) {
2894
- case "InternalException":
2895
- case "com.amazonaws.datasync#InternalException":
2896
- throw await de_InternalExceptionRes(parsedOutput, context);
2897
- case "InvalidRequestException":
2898
- case "com.amazonaws.datasync#InvalidRequestException":
2899
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2900
- default:
2901
- const parsedBody = parsedOutput.body;
2902
- return throwDefaultError({
2903
- output,
2904
- parsedBody,
2905
- errorCode
2906
- });
2907
- }
2908
- }, "de_UpdateLocationAzureBlobCommandError");
2909
1743
  var de_UpdateLocationHdfsCommand = /* @__PURE__ */ __name(async (output, context) => {
2910
1744
  if (output.statusCode >= 300) {
2911
- return de_UpdateLocationHdfsCommandError(output, context);
1745
+ return de_CommandError(output, context);
2912
1746
  }
2913
1747
  const data = await parseBody(output.body, context);
2914
1748
  let contents = {};
@@ -2919,31 +1753,9 @@ var de_UpdateLocationHdfsCommand = /* @__PURE__ */ __name(async (output, context
2919
1753
  };
2920
1754
  return response;
2921
1755
  }, "de_UpdateLocationHdfsCommand");
2922
- var de_UpdateLocationHdfsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2923
- const parsedOutput = {
2924
- ...output,
2925
- body: await parseErrorBody(output.body, context)
2926
- };
2927
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2928
- switch (errorCode) {
2929
- case "InternalException":
2930
- case "com.amazonaws.datasync#InternalException":
2931
- throw await de_InternalExceptionRes(parsedOutput, context);
2932
- case "InvalidRequestException":
2933
- case "com.amazonaws.datasync#InvalidRequestException":
2934
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2935
- default:
2936
- const parsedBody = parsedOutput.body;
2937
- return throwDefaultError({
2938
- output,
2939
- parsedBody,
2940
- errorCode
2941
- });
2942
- }
2943
- }, "de_UpdateLocationHdfsCommandError");
2944
1756
  var de_UpdateLocationNfsCommand = /* @__PURE__ */ __name(async (output, context) => {
2945
1757
  if (output.statusCode >= 300) {
2946
- return de_UpdateLocationNfsCommandError(output, context);
1758
+ return de_CommandError(output, context);
2947
1759
  }
2948
1760
  const data = await parseBody(output.body, context);
2949
1761
  let contents = {};
@@ -2954,31 +1766,9 @@ var de_UpdateLocationNfsCommand = /* @__PURE__ */ __name(async (output, context)
2954
1766
  };
2955
1767
  return response;
2956
1768
  }, "de_UpdateLocationNfsCommand");
2957
- var de_UpdateLocationNfsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2958
- const parsedOutput = {
2959
- ...output,
2960
- body: await parseErrorBody(output.body, context)
2961
- };
2962
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2963
- switch (errorCode) {
2964
- case "InternalException":
2965
- case "com.amazonaws.datasync#InternalException":
2966
- throw await de_InternalExceptionRes(parsedOutput, context);
2967
- case "InvalidRequestException":
2968
- case "com.amazonaws.datasync#InvalidRequestException":
2969
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
2970
- default:
2971
- const parsedBody = parsedOutput.body;
2972
- return throwDefaultError({
2973
- output,
2974
- parsedBody,
2975
- errorCode
2976
- });
2977
- }
2978
- }, "de_UpdateLocationNfsCommandError");
2979
1769
  var de_UpdateLocationObjectStorageCommand = /* @__PURE__ */ __name(async (output, context) => {
2980
1770
  if (output.statusCode >= 300) {
2981
- return de_UpdateLocationObjectStorageCommandError(output, context);
1771
+ return de_CommandError(output, context);
2982
1772
  }
2983
1773
  const data = await parseBody(output.body, context);
2984
1774
  let contents = {};
@@ -2989,31 +1779,9 @@ var de_UpdateLocationObjectStorageCommand = /* @__PURE__ */ __name(async (output
2989
1779
  };
2990
1780
  return response;
2991
1781
  }, "de_UpdateLocationObjectStorageCommand");
2992
- var de_UpdateLocationObjectStorageCommandError = /* @__PURE__ */ __name(async (output, context) => {
2993
- const parsedOutput = {
2994
- ...output,
2995
- body: await parseErrorBody(output.body, context)
2996
- };
2997
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2998
- switch (errorCode) {
2999
- case "InternalException":
3000
- case "com.amazonaws.datasync#InternalException":
3001
- throw await de_InternalExceptionRes(parsedOutput, context);
3002
- case "InvalidRequestException":
3003
- case "com.amazonaws.datasync#InvalidRequestException":
3004
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
3005
- default:
3006
- const parsedBody = parsedOutput.body;
3007
- return throwDefaultError({
3008
- output,
3009
- parsedBody,
3010
- errorCode
3011
- });
3012
- }
3013
- }, "de_UpdateLocationObjectStorageCommandError");
3014
1782
  var de_UpdateLocationSmbCommand = /* @__PURE__ */ __name(async (output, context) => {
3015
1783
  if (output.statusCode >= 300) {
3016
- return de_UpdateLocationSmbCommandError(output, context);
1784
+ return de_CommandError(output, context);
3017
1785
  }
3018
1786
  const data = await parseBody(output.body, context);
3019
1787
  let contents = {};
@@ -3024,31 +1792,9 @@ var de_UpdateLocationSmbCommand = /* @__PURE__ */ __name(async (output, context)
3024
1792
  };
3025
1793
  return response;
3026
1794
  }, "de_UpdateLocationSmbCommand");
3027
- var de_UpdateLocationSmbCommandError = /* @__PURE__ */ __name(async (output, context) => {
3028
- const parsedOutput = {
3029
- ...output,
3030
- body: await parseErrorBody(output.body, context)
3031
- };
3032
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3033
- switch (errorCode) {
3034
- case "InternalException":
3035
- case "com.amazonaws.datasync#InternalException":
3036
- throw await de_InternalExceptionRes(parsedOutput, context);
3037
- case "InvalidRequestException":
3038
- case "com.amazonaws.datasync#InvalidRequestException":
3039
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
3040
- default:
3041
- const parsedBody = parsedOutput.body;
3042
- return throwDefaultError({
3043
- output,
3044
- parsedBody,
3045
- errorCode
3046
- });
3047
- }
3048
- }, "de_UpdateLocationSmbCommandError");
3049
1795
  var de_UpdateStorageSystemCommand = /* @__PURE__ */ __name(async (output, context) => {
3050
1796
  if (output.statusCode >= 300) {
3051
- return de_UpdateStorageSystemCommandError(output, context);
1797
+ return de_CommandError(output, context);
3052
1798
  }
3053
1799
  const data = await parseBody(output.body, context);
3054
1800
  let contents = {};
@@ -3059,31 +1805,9 @@ var de_UpdateStorageSystemCommand = /* @__PURE__ */ __name(async (output, contex
3059
1805
  };
3060
1806
  return response;
3061
1807
  }, "de_UpdateStorageSystemCommand");
3062
- var de_UpdateStorageSystemCommandError = /* @__PURE__ */ __name(async (output, context) => {
3063
- const parsedOutput = {
3064
- ...output,
3065
- body: await parseErrorBody(output.body, context)
3066
- };
3067
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3068
- switch (errorCode) {
3069
- case "InternalException":
3070
- case "com.amazonaws.datasync#InternalException":
3071
- throw await de_InternalExceptionRes(parsedOutput, context);
3072
- case "InvalidRequestException":
3073
- case "com.amazonaws.datasync#InvalidRequestException":
3074
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
3075
- default:
3076
- const parsedBody = parsedOutput.body;
3077
- return throwDefaultError({
3078
- output,
3079
- parsedBody,
3080
- errorCode
3081
- });
3082
- }
3083
- }, "de_UpdateStorageSystemCommandError");
3084
1808
  var de_UpdateTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
3085
1809
  if (output.statusCode >= 300) {
3086
- return de_UpdateTaskCommandError(output, context);
1810
+ return de_CommandError(output, context);
3087
1811
  }
3088
1812
  const data = await parseBody(output.body, context);
3089
1813
  let contents = {};
@@ -3094,31 +1818,9 @@ var de_UpdateTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
3094
1818
  };
3095
1819
  return response;
3096
1820
  }, "de_UpdateTaskCommand");
3097
- var de_UpdateTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
3098
- const parsedOutput = {
3099
- ...output,
3100
- body: await parseErrorBody(output.body, context)
3101
- };
3102
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3103
- switch (errorCode) {
3104
- case "InternalException":
3105
- case "com.amazonaws.datasync#InternalException":
3106
- throw await de_InternalExceptionRes(parsedOutput, context);
3107
- case "InvalidRequestException":
3108
- case "com.amazonaws.datasync#InvalidRequestException":
3109
- throw await de_InvalidRequestExceptionRes(parsedOutput, context);
3110
- default:
3111
- const parsedBody = parsedOutput.body;
3112
- return throwDefaultError({
3113
- output,
3114
- parsedBody,
3115
- errorCode
3116
- });
3117
- }
3118
- }, "de_UpdateTaskCommandError");
3119
1821
  var de_UpdateTaskExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
3120
1822
  if (output.statusCode >= 300) {
3121
- return de_UpdateTaskExecutionCommandError(output, context);
1823
+ return de_CommandError(output, context);
3122
1824
  }
3123
1825
  const data = await parseBody(output.body, context);
3124
1826
  let contents = {};
@@ -3129,7 +1831,7 @@ var de_UpdateTaskExecutionCommand = /* @__PURE__ */ __name(async (output, contex
3129
1831
  };
3130
1832
  return response;
3131
1833
  }, "de_UpdateTaskExecutionCommand");
3132
- var de_UpdateTaskExecutionCommandError = /* @__PURE__ */ __name(async (output, context) => {
1834
+ var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
3133
1835
  const parsedOutput = {
3134
1836
  ...output,
3135
1837
  body: await parseErrorBody(output.body, context)
@@ -3150,7 +1852,7 @@ var de_UpdateTaskExecutionCommandError = /* @__PURE__ */ __name(async (output, c
3150
1852
  errorCode
3151
1853
  });
3152
1854
  }
3153
- }, "de_UpdateTaskExecutionCommandError");
1855
+ }, "de_CommandError");
3154
1856
  var de_InternalExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
3155
1857
  const body = parsedOutput.body;
3156
1858
  const deserialized = (0, import_smithy_client._json)(body);