@aws-sdk/client-storage-gateway 3.504.0 → 3.507.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist-cjs/index.js +126 -2087
- package/dist-es/protocols/Aws_json1_1.js +109 -2070
- package/package.json +3 -3
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
1470
|
-
|
|
1471
|
-
|
|
1472
|
-
|
|
1473
|
-
|
|
1474
|
-
|
|
1475
|
-
|
|
1476
|
-
|
|
1477
|
-
|
|
1478
|
-
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
3226
|
-
|
|
3227
|
-
|
|
3228
|
-
|
|
3229
|
-
|
|
3230
|
-
|
|
3231
|
-
|
|
3232
|
-
|
|
3233
|
-
|
|
3234
|
-
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
-
}, "
|
|
3715
|
-
var
|
|
3716
|
-
|
|
3717
|
-
|
|
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
|
-
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
-
}, "
|
|
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);
|