@aws-sdk/client-storage-gateway 3.52.0 → 3.53.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/CHANGELOG.md +11 -0
- package/dist-cjs/index.js +3 -0
- package/dist-cjs/models/StorageGatewayServiceException.js +11 -0
- package/dist-cjs/models/models_0.js +48 -5
- package/dist-cjs/protocols/Aws_json1_1.js +619 -2040
- package/dist-es/index.js +1 -0
- package/dist-es/models/StorageGatewayServiceException.js +12 -0
- package/dist-es/models/models_0.js +41 -1
- package/dist-es/protocols/Aws_json1_1.js +1522 -2395
- package/dist-types/index.d.ts +1 -0
- package/dist-types/models/StorageGatewayServiceException.d.ts +10 -0
- package/dist-types/models/models_0.d.ts +23 -22
- package/dist-types/ts3.4/index.d.ts +1 -0
- package/dist-types/ts3.4/models/StorageGatewayServiceException.d.ts +6 -0
- package/dist-types/ts3.4/models/models_0.d.ts +17 -16
- package/package.json +25 -25
|
@@ -6,6 +6,8 @@ exports.deserializeAws_json1_1ListTapePoolsCommand = exports.deserializeAws_json
|
|
|
6
6
|
exports.deserializeAws_json1_1UpdateVTLDeviceTypeCommand = exports.deserializeAws_json1_1UpdateSnapshotScheduleCommand = exports.deserializeAws_json1_1UpdateSMBSecurityStrategyCommand = exports.deserializeAws_json1_1UpdateSMBLocalGroupsCommand = exports.deserializeAws_json1_1UpdateSMBFileShareVisibilityCommand = exports.deserializeAws_json1_1UpdateSMBFileShareCommand = exports.deserializeAws_json1_1UpdateNFSFileShareCommand = exports.deserializeAws_json1_1UpdateMaintenanceStartTimeCommand = exports.deserializeAws_json1_1UpdateGatewaySoftwareNowCommand = exports.deserializeAws_json1_1UpdateGatewayInformationCommand = exports.deserializeAws_json1_1UpdateFileSystemAssociationCommand = exports.deserializeAws_json1_1UpdateChapCredentialsCommand = exports.deserializeAws_json1_1UpdateBandwidthRateLimitScheduleCommand = exports.deserializeAws_json1_1UpdateBandwidthRateLimitCommand = exports.deserializeAws_json1_1UpdateAutomaticTapeCreationPolicyCommand = exports.deserializeAws_json1_1StartGatewayCommand = exports.deserializeAws_json1_1StartAvailabilityMonitorTestCommand = exports.deserializeAws_json1_1ShutdownGatewayCommand = exports.deserializeAws_json1_1SetSMBGuestPasswordCommand = exports.deserializeAws_json1_1SetLocalConsolePasswordCommand = exports.deserializeAws_json1_1RetrieveTapeRecoveryPointCommand = exports.deserializeAws_json1_1RetrieveTapeArchiveCommand = exports.deserializeAws_json1_1ResetCacheCommand = exports.deserializeAws_json1_1RemoveTagsFromResourceCommand = exports.deserializeAws_json1_1RefreshCacheCommand = exports.deserializeAws_json1_1NotifyWhenUploadedCommand = exports.deserializeAws_json1_1ListVolumesCommand = exports.deserializeAws_json1_1ListVolumeRecoveryPointsCommand = exports.deserializeAws_json1_1ListVolumeInitiatorsCommand = exports.deserializeAws_json1_1ListTapesCommand = void 0;
|
|
7
7
|
const protocol_http_1 = require("@aws-sdk/protocol-http");
|
|
8
8
|
const smithy_client_1 = require("@aws-sdk/smithy-client");
|
|
9
|
+
const models_0_1 = require("../models/models_0");
|
|
10
|
+
const StorageGatewayServiceException_1 = require("../models/StorageGatewayServiceException");
|
|
9
11
|
const serializeAws_json1_1ActivateGatewayCommand = async (input, context) => {
|
|
10
12
|
const headers = {
|
|
11
13
|
"content-type": "application/x-amz-json-1.1",
|
|
@@ -931,35 +933,19 @@ const deserializeAws_json1_1ActivateGatewayCommandError = async (output, context
|
|
|
931
933
|
switch (errorCode) {
|
|
932
934
|
case "InternalServerError":
|
|
933
935
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
934
|
-
|
|
935
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
936
|
-
name: errorCode,
|
|
937
|
-
$metadata: deserializeMetadata(output),
|
|
938
|
-
};
|
|
939
|
-
break;
|
|
936
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
940
937
|
case "InvalidGatewayRequestException":
|
|
941
938
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
942
|
-
|
|
943
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
944
|
-
name: errorCode,
|
|
945
|
-
$metadata: deserializeMetadata(output),
|
|
946
|
-
};
|
|
947
|
-
break;
|
|
939
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
948
940
|
default:
|
|
949
941
|
const parsedBody = parsedOutput.body;
|
|
950
|
-
|
|
951
|
-
|
|
952
|
-
...parsedBody,
|
|
953
|
-
name: `${errorCode}`,
|
|
954
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
942
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
943
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
955
944
|
$fault: "client",
|
|
956
945
|
$metadata: deserializeMetadata(output),
|
|
957
|
-
};
|
|
946
|
+
});
|
|
947
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
958
948
|
}
|
|
959
|
-
const message = response.message || response.Message || errorCode;
|
|
960
|
-
response.message = message;
|
|
961
|
-
delete response.Message;
|
|
962
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
963
949
|
};
|
|
964
950
|
const deserializeAws_json1_1AddCacheCommand = async (output, context) => {
|
|
965
951
|
if (output.statusCode >= 300) {
|
|
@@ -986,35 +972,19 @@ const deserializeAws_json1_1AddCacheCommandError = async (output, context) => {
|
|
|
986
972
|
switch (errorCode) {
|
|
987
973
|
case "InternalServerError":
|
|
988
974
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
989
|
-
|
|
990
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
991
|
-
name: errorCode,
|
|
992
|
-
$metadata: deserializeMetadata(output),
|
|
993
|
-
};
|
|
994
|
-
break;
|
|
975
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
995
976
|
case "InvalidGatewayRequestException":
|
|
996
977
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
997
|
-
|
|
998
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
999
|
-
name: errorCode,
|
|
1000
|
-
$metadata: deserializeMetadata(output),
|
|
1001
|
-
};
|
|
1002
|
-
break;
|
|
978
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1003
979
|
default:
|
|
1004
980
|
const parsedBody = parsedOutput.body;
|
|
1005
|
-
|
|
1006
|
-
|
|
1007
|
-
...parsedBody,
|
|
1008
|
-
name: `${errorCode}`,
|
|
1009
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
981
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
982
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1010
983
|
$fault: "client",
|
|
1011
984
|
$metadata: deserializeMetadata(output),
|
|
1012
|
-
};
|
|
985
|
+
});
|
|
986
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1013
987
|
}
|
|
1014
|
-
const message = response.message || response.Message || errorCode;
|
|
1015
|
-
response.message = message;
|
|
1016
|
-
delete response.Message;
|
|
1017
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1018
988
|
};
|
|
1019
989
|
const deserializeAws_json1_1AddTagsToResourceCommand = async (output, context) => {
|
|
1020
990
|
if (output.statusCode >= 300) {
|
|
@@ -1041,35 +1011,19 @@ const deserializeAws_json1_1AddTagsToResourceCommandError = async (output, conte
|
|
|
1041
1011
|
switch (errorCode) {
|
|
1042
1012
|
case "InternalServerError":
|
|
1043
1013
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1044
|
-
|
|
1045
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1046
|
-
name: errorCode,
|
|
1047
|
-
$metadata: deserializeMetadata(output),
|
|
1048
|
-
};
|
|
1049
|
-
break;
|
|
1014
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1050
1015
|
case "InvalidGatewayRequestException":
|
|
1051
1016
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1052
|
-
|
|
1053
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1054
|
-
name: errorCode,
|
|
1055
|
-
$metadata: deserializeMetadata(output),
|
|
1056
|
-
};
|
|
1057
|
-
break;
|
|
1017
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1058
1018
|
default:
|
|
1059
1019
|
const parsedBody = parsedOutput.body;
|
|
1060
|
-
|
|
1061
|
-
|
|
1062
|
-
...parsedBody,
|
|
1063
|
-
name: `${errorCode}`,
|
|
1064
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1020
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1021
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1065
1022
|
$fault: "client",
|
|
1066
1023
|
$metadata: deserializeMetadata(output),
|
|
1067
|
-
};
|
|
1024
|
+
});
|
|
1025
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1068
1026
|
}
|
|
1069
|
-
const message = response.message || response.Message || errorCode;
|
|
1070
|
-
response.message = message;
|
|
1071
|
-
delete response.Message;
|
|
1072
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1073
1027
|
};
|
|
1074
1028
|
const deserializeAws_json1_1AddUploadBufferCommand = async (output, context) => {
|
|
1075
1029
|
if (output.statusCode >= 300) {
|
|
@@ -1096,35 +1050,19 @@ const deserializeAws_json1_1AddUploadBufferCommandError = async (output, context
|
|
|
1096
1050
|
switch (errorCode) {
|
|
1097
1051
|
case "InternalServerError":
|
|
1098
1052
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1099
|
-
|
|
1100
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1101
|
-
name: errorCode,
|
|
1102
|
-
$metadata: deserializeMetadata(output),
|
|
1103
|
-
};
|
|
1104
|
-
break;
|
|
1053
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1105
1054
|
case "InvalidGatewayRequestException":
|
|
1106
1055
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1107
|
-
|
|
1108
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1109
|
-
name: errorCode,
|
|
1110
|
-
$metadata: deserializeMetadata(output),
|
|
1111
|
-
};
|
|
1112
|
-
break;
|
|
1056
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1113
1057
|
default:
|
|
1114
1058
|
const parsedBody = parsedOutput.body;
|
|
1115
|
-
|
|
1116
|
-
|
|
1117
|
-
...parsedBody,
|
|
1118
|
-
name: `${errorCode}`,
|
|
1119
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1059
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1060
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1120
1061
|
$fault: "client",
|
|
1121
1062
|
$metadata: deserializeMetadata(output),
|
|
1122
|
-
};
|
|
1063
|
+
});
|
|
1064
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1123
1065
|
}
|
|
1124
|
-
const message = response.message || response.Message || errorCode;
|
|
1125
|
-
response.message = message;
|
|
1126
|
-
delete response.Message;
|
|
1127
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1128
1066
|
};
|
|
1129
1067
|
const deserializeAws_json1_1AddWorkingStorageCommand = async (output, context) => {
|
|
1130
1068
|
if (output.statusCode >= 300) {
|
|
@@ -1151,35 +1089,19 @@ const deserializeAws_json1_1AddWorkingStorageCommandError = async (output, conte
|
|
|
1151
1089
|
switch (errorCode) {
|
|
1152
1090
|
case "InternalServerError":
|
|
1153
1091
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1154
|
-
|
|
1155
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1156
|
-
name: errorCode,
|
|
1157
|
-
$metadata: deserializeMetadata(output),
|
|
1158
|
-
};
|
|
1159
|
-
break;
|
|
1092
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1160
1093
|
case "InvalidGatewayRequestException":
|
|
1161
1094
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1162
|
-
|
|
1163
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1164
|
-
name: errorCode,
|
|
1165
|
-
$metadata: deserializeMetadata(output),
|
|
1166
|
-
};
|
|
1167
|
-
break;
|
|
1095
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1168
1096
|
default:
|
|
1169
1097
|
const parsedBody = parsedOutput.body;
|
|
1170
|
-
|
|
1171
|
-
|
|
1172
|
-
...parsedBody,
|
|
1173
|
-
name: `${errorCode}`,
|
|
1174
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1098
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1099
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1175
1100
|
$fault: "client",
|
|
1176
1101
|
$metadata: deserializeMetadata(output),
|
|
1177
|
-
};
|
|
1102
|
+
});
|
|
1103
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1178
1104
|
}
|
|
1179
|
-
const message = response.message || response.Message || errorCode;
|
|
1180
|
-
response.message = message;
|
|
1181
|
-
delete response.Message;
|
|
1182
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1183
1105
|
};
|
|
1184
1106
|
const deserializeAws_json1_1AssignTapePoolCommand = async (output, context) => {
|
|
1185
1107
|
if (output.statusCode >= 300) {
|
|
@@ -1206,35 +1128,19 @@ const deserializeAws_json1_1AssignTapePoolCommandError = async (output, context)
|
|
|
1206
1128
|
switch (errorCode) {
|
|
1207
1129
|
case "InternalServerError":
|
|
1208
1130
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1209
|
-
|
|
1210
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1211
|
-
name: errorCode,
|
|
1212
|
-
$metadata: deserializeMetadata(output),
|
|
1213
|
-
};
|
|
1214
|
-
break;
|
|
1131
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1215
1132
|
case "InvalidGatewayRequestException":
|
|
1216
1133
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1217
|
-
|
|
1218
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1219
|
-
name: errorCode,
|
|
1220
|
-
$metadata: deserializeMetadata(output),
|
|
1221
|
-
};
|
|
1222
|
-
break;
|
|
1134
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1223
1135
|
default:
|
|
1224
1136
|
const parsedBody = parsedOutput.body;
|
|
1225
|
-
|
|
1226
|
-
|
|
1227
|
-
...parsedBody,
|
|
1228
|
-
name: `${errorCode}`,
|
|
1229
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1137
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1138
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1230
1139
|
$fault: "client",
|
|
1231
1140
|
$metadata: deserializeMetadata(output),
|
|
1232
|
-
};
|
|
1141
|
+
});
|
|
1142
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1233
1143
|
}
|
|
1234
|
-
const message = response.message || response.Message || errorCode;
|
|
1235
|
-
response.message = message;
|
|
1236
|
-
delete response.Message;
|
|
1237
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1238
1144
|
};
|
|
1239
1145
|
const deserializeAws_json1_1AssociateFileSystemCommand = async (output, context) => {
|
|
1240
1146
|
if (output.statusCode >= 300) {
|
|
@@ -1261,35 +1167,19 @@ const deserializeAws_json1_1AssociateFileSystemCommandError = async (output, con
|
|
|
1261
1167
|
switch (errorCode) {
|
|
1262
1168
|
case "InternalServerError":
|
|
1263
1169
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1264
|
-
|
|
1265
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1266
|
-
name: errorCode,
|
|
1267
|
-
$metadata: deserializeMetadata(output),
|
|
1268
|
-
};
|
|
1269
|
-
break;
|
|
1170
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1270
1171
|
case "InvalidGatewayRequestException":
|
|
1271
1172
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1272
|
-
|
|
1273
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1274
|
-
name: errorCode,
|
|
1275
|
-
$metadata: deserializeMetadata(output),
|
|
1276
|
-
};
|
|
1277
|
-
break;
|
|
1173
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1278
1174
|
default:
|
|
1279
1175
|
const parsedBody = parsedOutput.body;
|
|
1280
|
-
|
|
1281
|
-
|
|
1282
|
-
...parsedBody,
|
|
1283
|
-
name: `${errorCode}`,
|
|
1284
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1176
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1177
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1285
1178
|
$fault: "client",
|
|
1286
1179
|
$metadata: deserializeMetadata(output),
|
|
1287
|
-
};
|
|
1180
|
+
});
|
|
1181
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1288
1182
|
}
|
|
1289
|
-
const message = response.message || response.Message || errorCode;
|
|
1290
|
-
response.message = message;
|
|
1291
|
-
delete response.Message;
|
|
1292
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1293
1183
|
};
|
|
1294
1184
|
const deserializeAws_json1_1AttachVolumeCommand = async (output, context) => {
|
|
1295
1185
|
if (output.statusCode >= 300) {
|
|
@@ -1316,35 +1206,19 @@ const deserializeAws_json1_1AttachVolumeCommandError = async (output, context) =
|
|
|
1316
1206
|
switch (errorCode) {
|
|
1317
1207
|
case "InternalServerError":
|
|
1318
1208
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1319
|
-
|
|
1320
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1321
|
-
name: errorCode,
|
|
1322
|
-
$metadata: deserializeMetadata(output),
|
|
1323
|
-
};
|
|
1324
|
-
break;
|
|
1209
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1325
1210
|
case "InvalidGatewayRequestException":
|
|
1326
1211
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1327
|
-
|
|
1328
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1329
|
-
name: errorCode,
|
|
1330
|
-
$metadata: deserializeMetadata(output),
|
|
1331
|
-
};
|
|
1332
|
-
break;
|
|
1212
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1333
1213
|
default:
|
|
1334
1214
|
const parsedBody = parsedOutput.body;
|
|
1335
|
-
|
|
1336
|
-
|
|
1337
|
-
...parsedBody,
|
|
1338
|
-
name: `${errorCode}`,
|
|
1339
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1215
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1216
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1340
1217
|
$fault: "client",
|
|
1341
1218
|
$metadata: deserializeMetadata(output),
|
|
1342
|
-
};
|
|
1219
|
+
});
|
|
1220
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1343
1221
|
}
|
|
1344
|
-
const message = response.message || response.Message || errorCode;
|
|
1345
|
-
response.message = message;
|
|
1346
|
-
delete response.Message;
|
|
1347
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1348
1222
|
};
|
|
1349
1223
|
const deserializeAws_json1_1CancelArchivalCommand = async (output, context) => {
|
|
1350
1224
|
if (output.statusCode >= 300) {
|
|
@@ -1371,35 +1245,19 @@ const deserializeAws_json1_1CancelArchivalCommandError = async (output, context)
|
|
|
1371
1245
|
switch (errorCode) {
|
|
1372
1246
|
case "InternalServerError":
|
|
1373
1247
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1374
|
-
|
|
1375
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1376
|
-
name: errorCode,
|
|
1377
|
-
$metadata: deserializeMetadata(output),
|
|
1378
|
-
};
|
|
1379
|
-
break;
|
|
1248
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1380
1249
|
case "InvalidGatewayRequestException":
|
|
1381
1250
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1382
|
-
|
|
1383
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1384
|
-
name: errorCode,
|
|
1385
|
-
$metadata: deserializeMetadata(output),
|
|
1386
|
-
};
|
|
1387
|
-
break;
|
|
1251
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1388
1252
|
default:
|
|
1389
1253
|
const parsedBody = parsedOutput.body;
|
|
1390
|
-
|
|
1391
|
-
|
|
1392
|
-
...parsedBody,
|
|
1393
|
-
name: `${errorCode}`,
|
|
1394
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1254
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1255
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1395
1256
|
$fault: "client",
|
|
1396
1257
|
$metadata: deserializeMetadata(output),
|
|
1397
|
-
};
|
|
1258
|
+
});
|
|
1259
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1398
1260
|
}
|
|
1399
|
-
const message = response.message || response.Message || errorCode;
|
|
1400
|
-
response.message = message;
|
|
1401
|
-
delete response.Message;
|
|
1402
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1403
1261
|
};
|
|
1404
1262
|
const deserializeAws_json1_1CancelRetrievalCommand = async (output, context) => {
|
|
1405
1263
|
if (output.statusCode >= 300) {
|
|
@@ -1426,35 +1284,19 @@ const deserializeAws_json1_1CancelRetrievalCommandError = async (output, context
|
|
|
1426
1284
|
switch (errorCode) {
|
|
1427
1285
|
case "InternalServerError":
|
|
1428
1286
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1429
|
-
|
|
1430
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1431
|
-
name: errorCode,
|
|
1432
|
-
$metadata: deserializeMetadata(output),
|
|
1433
|
-
};
|
|
1434
|
-
break;
|
|
1287
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1435
1288
|
case "InvalidGatewayRequestException":
|
|
1436
1289
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1437
|
-
|
|
1438
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1439
|
-
name: errorCode,
|
|
1440
|
-
$metadata: deserializeMetadata(output),
|
|
1441
|
-
};
|
|
1442
|
-
break;
|
|
1290
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1443
1291
|
default:
|
|
1444
1292
|
const parsedBody = parsedOutput.body;
|
|
1445
|
-
|
|
1446
|
-
|
|
1447
|
-
...parsedBody,
|
|
1448
|
-
name: `${errorCode}`,
|
|
1449
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1293
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1294
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1450
1295
|
$fault: "client",
|
|
1451
1296
|
$metadata: deserializeMetadata(output),
|
|
1452
|
-
};
|
|
1297
|
+
});
|
|
1298
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1453
1299
|
}
|
|
1454
|
-
const message = response.message || response.Message || errorCode;
|
|
1455
|
-
response.message = message;
|
|
1456
|
-
delete response.Message;
|
|
1457
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1458
1300
|
};
|
|
1459
1301
|
const deserializeAws_json1_1CreateCachediSCSIVolumeCommand = async (output, context) => {
|
|
1460
1302
|
if (output.statusCode >= 300) {
|
|
@@ -1481,35 +1323,19 @@ const deserializeAws_json1_1CreateCachediSCSIVolumeCommandError = async (output,
|
|
|
1481
1323
|
switch (errorCode) {
|
|
1482
1324
|
case "InternalServerError":
|
|
1483
1325
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1484
|
-
|
|
1485
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1486
|
-
name: errorCode,
|
|
1487
|
-
$metadata: deserializeMetadata(output),
|
|
1488
|
-
};
|
|
1489
|
-
break;
|
|
1326
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1490
1327
|
case "InvalidGatewayRequestException":
|
|
1491
1328
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1492
|
-
|
|
1493
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1494
|
-
name: errorCode,
|
|
1495
|
-
$metadata: deserializeMetadata(output),
|
|
1496
|
-
};
|
|
1497
|
-
break;
|
|
1329
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1498
1330
|
default:
|
|
1499
1331
|
const parsedBody = parsedOutput.body;
|
|
1500
|
-
|
|
1501
|
-
|
|
1502
|
-
...parsedBody,
|
|
1503
|
-
name: `${errorCode}`,
|
|
1504
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1332
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1333
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1505
1334
|
$fault: "client",
|
|
1506
1335
|
$metadata: deserializeMetadata(output),
|
|
1507
|
-
};
|
|
1336
|
+
});
|
|
1337
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1508
1338
|
}
|
|
1509
|
-
const message = response.message || response.Message || errorCode;
|
|
1510
|
-
response.message = message;
|
|
1511
|
-
delete response.Message;
|
|
1512
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1513
1339
|
};
|
|
1514
1340
|
const deserializeAws_json1_1CreateNFSFileShareCommand = async (output, context) => {
|
|
1515
1341
|
if (output.statusCode >= 300) {
|
|
@@ -1536,35 +1362,19 @@ const deserializeAws_json1_1CreateNFSFileShareCommandError = async (output, cont
|
|
|
1536
1362
|
switch (errorCode) {
|
|
1537
1363
|
case "InternalServerError":
|
|
1538
1364
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1539
|
-
|
|
1540
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1541
|
-
name: errorCode,
|
|
1542
|
-
$metadata: deserializeMetadata(output),
|
|
1543
|
-
};
|
|
1544
|
-
break;
|
|
1365
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1545
1366
|
case "InvalidGatewayRequestException":
|
|
1546
1367
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1547
|
-
|
|
1548
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1549
|
-
name: errorCode,
|
|
1550
|
-
$metadata: deserializeMetadata(output),
|
|
1551
|
-
};
|
|
1552
|
-
break;
|
|
1368
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1553
1369
|
default:
|
|
1554
1370
|
const parsedBody = parsedOutput.body;
|
|
1555
|
-
|
|
1556
|
-
|
|
1557
|
-
...parsedBody,
|
|
1558
|
-
name: `${errorCode}`,
|
|
1559
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1371
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1372
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1560
1373
|
$fault: "client",
|
|
1561
1374
|
$metadata: deserializeMetadata(output),
|
|
1562
|
-
};
|
|
1375
|
+
});
|
|
1376
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1563
1377
|
}
|
|
1564
|
-
const message = response.message || response.Message || errorCode;
|
|
1565
|
-
response.message = message;
|
|
1566
|
-
delete response.Message;
|
|
1567
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1568
1378
|
};
|
|
1569
1379
|
const deserializeAws_json1_1CreateSMBFileShareCommand = async (output, context) => {
|
|
1570
1380
|
if (output.statusCode >= 300) {
|
|
@@ -1591,35 +1401,19 @@ const deserializeAws_json1_1CreateSMBFileShareCommandError = async (output, cont
|
|
|
1591
1401
|
switch (errorCode) {
|
|
1592
1402
|
case "InternalServerError":
|
|
1593
1403
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1594
|
-
|
|
1595
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1596
|
-
name: errorCode,
|
|
1597
|
-
$metadata: deserializeMetadata(output),
|
|
1598
|
-
};
|
|
1599
|
-
break;
|
|
1404
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1600
1405
|
case "InvalidGatewayRequestException":
|
|
1601
1406
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1602
|
-
|
|
1603
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1604
|
-
name: errorCode,
|
|
1605
|
-
$metadata: deserializeMetadata(output),
|
|
1606
|
-
};
|
|
1607
|
-
break;
|
|
1407
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1608
1408
|
default:
|
|
1609
1409
|
const parsedBody = parsedOutput.body;
|
|
1610
|
-
|
|
1611
|
-
|
|
1612
|
-
...parsedBody,
|
|
1613
|
-
name: `${errorCode}`,
|
|
1614
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1410
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1411
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1615
1412
|
$fault: "client",
|
|
1616
1413
|
$metadata: deserializeMetadata(output),
|
|
1617
|
-
};
|
|
1414
|
+
});
|
|
1415
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1618
1416
|
}
|
|
1619
|
-
const message = response.message || response.Message || errorCode;
|
|
1620
|
-
response.message = message;
|
|
1621
|
-
delete response.Message;
|
|
1622
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1623
1417
|
};
|
|
1624
1418
|
const deserializeAws_json1_1CreateSnapshotCommand = async (output, context) => {
|
|
1625
1419
|
if (output.statusCode >= 300) {
|
|
@@ -1646,43 +1440,22 @@ const deserializeAws_json1_1CreateSnapshotCommandError = async (output, context)
|
|
|
1646
1440
|
switch (errorCode) {
|
|
1647
1441
|
case "InternalServerError":
|
|
1648
1442
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1649
|
-
|
|
1650
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1651
|
-
name: errorCode,
|
|
1652
|
-
$metadata: deserializeMetadata(output),
|
|
1653
|
-
};
|
|
1654
|
-
break;
|
|
1443
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1655
1444
|
case "InvalidGatewayRequestException":
|
|
1656
1445
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1657
|
-
|
|
1658
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1659
|
-
name: errorCode,
|
|
1660
|
-
$metadata: deserializeMetadata(output),
|
|
1661
|
-
};
|
|
1662
|
-
break;
|
|
1446
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1663
1447
|
case "ServiceUnavailableError":
|
|
1664
1448
|
case "com.amazonaws.storagegateway#ServiceUnavailableError":
|
|
1665
|
-
|
|
1666
|
-
...(await deserializeAws_json1_1ServiceUnavailableErrorResponse(parsedOutput, context)),
|
|
1667
|
-
name: errorCode,
|
|
1668
|
-
$metadata: deserializeMetadata(output),
|
|
1669
|
-
};
|
|
1670
|
-
break;
|
|
1449
|
+
throw await deserializeAws_json1_1ServiceUnavailableErrorResponse(parsedOutput, context);
|
|
1671
1450
|
default:
|
|
1672
1451
|
const parsedBody = parsedOutput.body;
|
|
1673
|
-
|
|
1674
|
-
|
|
1675
|
-
...parsedBody,
|
|
1676
|
-
name: `${errorCode}`,
|
|
1677
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1452
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1453
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1678
1454
|
$fault: "client",
|
|
1679
1455
|
$metadata: deserializeMetadata(output),
|
|
1680
|
-
};
|
|
1456
|
+
});
|
|
1457
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1681
1458
|
}
|
|
1682
|
-
const message = response.message || response.Message || errorCode;
|
|
1683
|
-
response.message = message;
|
|
1684
|
-
delete response.Message;
|
|
1685
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1686
1459
|
};
|
|
1687
1460
|
const deserializeAws_json1_1CreateSnapshotFromVolumeRecoveryPointCommand = async (output, context) => {
|
|
1688
1461
|
if (output.statusCode >= 300) {
|
|
@@ -1709,43 +1482,22 @@ const deserializeAws_json1_1CreateSnapshotFromVolumeRecoveryPointCommandError =
|
|
|
1709
1482
|
switch (errorCode) {
|
|
1710
1483
|
case "InternalServerError":
|
|
1711
1484
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1712
|
-
|
|
1713
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1714
|
-
name: errorCode,
|
|
1715
|
-
$metadata: deserializeMetadata(output),
|
|
1716
|
-
};
|
|
1717
|
-
break;
|
|
1485
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1718
1486
|
case "InvalidGatewayRequestException":
|
|
1719
1487
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1720
|
-
|
|
1721
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1722
|
-
name: errorCode,
|
|
1723
|
-
$metadata: deserializeMetadata(output),
|
|
1724
|
-
};
|
|
1725
|
-
break;
|
|
1488
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1726
1489
|
case "ServiceUnavailableError":
|
|
1727
1490
|
case "com.amazonaws.storagegateway#ServiceUnavailableError":
|
|
1728
|
-
|
|
1729
|
-
...(await deserializeAws_json1_1ServiceUnavailableErrorResponse(parsedOutput, context)),
|
|
1730
|
-
name: errorCode,
|
|
1731
|
-
$metadata: deserializeMetadata(output),
|
|
1732
|
-
};
|
|
1733
|
-
break;
|
|
1491
|
+
throw await deserializeAws_json1_1ServiceUnavailableErrorResponse(parsedOutput, context);
|
|
1734
1492
|
default:
|
|
1735
1493
|
const parsedBody = parsedOutput.body;
|
|
1736
|
-
|
|
1737
|
-
|
|
1738
|
-
...parsedBody,
|
|
1739
|
-
name: `${errorCode}`,
|
|
1740
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1494
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1495
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1741
1496
|
$fault: "client",
|
|
1742
1497
|
$metadata: deserializeMetadata(output),
|
|
1743
|
-
};
|
|
1498
|
+
});
|
|
1499
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1744
1500
|
}
|
|
1745
|
-
const message = response.message || response.Message || errorCode;
|
|
1746
|
-
response.message = message;
|
|
1747
|
-
delete response.Message;
|
|
1748
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1749
1501
|
};
|
|
1750
1502
|
const deserializeAws_json1_1CreateStorediSCSIVolumeCommand = async (output, context) => {
|
|
1751
1503
|
if (output.statusCode >= 300) {
|
|
@@ -1772,35 +1524,19 @@ const deserializeAws_json1_1CreateStorediSCSIVolumeCommandError = async (output,
|
|
|
1772
1524
|
switch (errorCode) {
|
|
1773
1525
|
case "InternalServerError":
|
|
1774
1526
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1775
|
-
|
|
1776
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1777
|
-
name: errorCode,
|
|
1778
|
-
$metadata: deserializeMetadata(output),
|
|
1779
|
-
};
|
|
1780
|
-
break;
|
|
1527
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1781
1528
|
case "InvalidGatewayRequestException":
|
|
1782
1529
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1783
|
-
|
|
1784
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1785
|
-
name: errorCode,
|
|
1786
|
-
$metadata: deserializeMetadata(output),
|
|
1787
|
-
};
|
|
1788
|
-
break;
|
|
1530
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1789
1531
|
default:
|
|
1790
1532
|
const parsedBody = parsedOutput.body;
|
|
1791
|
-
|
|
1792
|
-
|
|
1793
|
-
...parsedBody,
|
|
1794
|
-
name: `${errorCode}`,
|
|
1795
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1533
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1534
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1796
1535
|
$fault: "client",
|
|
1797
1536
|
$metadata: deserializeMetadata(output),
|
|
1798
|
-
};
|
|
1537
|
+
});
|
|
1538
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1799
1539
|
}
|
|
1800
|
-
const message = response.message || response.Message || errorCode;
|
|
1801
|
-
response.message = message;
|
|
1802
|
-
delete response.Message;
|
|
1803
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1804
1540
|
};
|
|
1805
1541
|
const deserializeAws_json1_1CreateTapePoolCommand = async (output, context) => {
|
|
1806
1542
|
if (output.statusCode >= 300) {
|
|
@@ -1827,35 +1563,19 @@ const deserializeAws_json1_1CreateTapePoolCommandError = async (output, context)
|
|
|
1827
1563
|
switch (errorCode) {
|
|
1828
1564
|
case "InternalServerError":
|
|
1829
1565
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1830
|
-
|
|
1831
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1832
|
-
name: errorCode,
|
|
1833
|
-
$metadata: deserializeMetadata(output),
|
|
1834
|
-
};
|
|
1835
|
-
break;
|
|
1566
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1836
1567
|
case "InvalidGatewayRequestException":
|
|
1837
1568
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1838
|
-
|
|
1839
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1840
|
-
name: errorCode,
|
|
1841
|
-
$metadata: deserializeMetadata(output),
|
|
1842
|
-
};
|
|
1843
|
-
break;
|
|
1569
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1844
1570
|
default:
|
|
1845
1571
|
const parsedBody = parsedOutput.body;
|
|
1846
|
-
|
|
1847
|
-
|
|
1848
|
-
...parsedBody,
|
|
1849
|
-
name: `${errorCode}`,
|
|
1850
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1572
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1573
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1851
1574
|
$fault: "client",
|
|
1852
1575
|
$metadata: deserializeMetadata(output),
|
|
1853
|
-
};
|
|
1576
|
+
});
|
|
1577
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1854
1578
|
}
|
|
1855
|
-
const message = response.message || response.Message || errorCode;
|
|
1856
|
-
response.message = message;
|
|
1857
|
-
delete response.Message;
|
|
1858
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1859
1579
|
};
|
|
1860
1580
|
const deserializeAws_json1_1CreateTapesCommand = async (output, context) => {
|
|
1861
1581
|
if (output.statusCode >= 300) {
|
|
@@ -1882,35 +1602,19 @@ const deserializeAws_json1_1CreateTapesCommandError = async (output, context) =>
|
|
|
1882
1602
|
switch (errorCode) {
|
|
1883
1603
|
case "InternalServerError":
|
|
1884
1604
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1885
|
-
|
|
1886
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1887
|
-
name: errorCode,
|
|
1888
|
-
$metadata: deserializeMetadata(output),
|
|
1889
|
-
};
|
|
1890
|
-
break;
|
|
1605
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1891
1606
|
case "InvalidGatewayRequestException":
|
|
1892
1607
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1893
|
-
|
|
1894
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1895
|
-
name: errorCode,
|
|
1896
|
-
$metadata: deserializeMetadata(output),
|
|
1897
|
-
};
|
|
1898
|
-
break;
|
|
1608
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1899
1609
|
default:
|
|
1900
1610
|
const parsedBody = parsedOutput.body;
|
|
1901
|
-
|
|
1902
|
-
|
|
1903
|
-
...parsedBody,
|
|
1904
|
-
name: `${errorCode}`,
|
|
1905
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1611
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1612
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1906
1613
|
$fault: "client",
|
|
1907
1614
|
$metadata: deserializeMetadata(output),
|
|
1908
|
-
};
|
|
1615
|
+
});
|
|
1616
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1909
1617
|
}
|
|
1910
|
-
const message = response.message || response.Message || errorCode;
|
|
1911
|
-
response.message = message;
|
|
1912
|
-
delete response.Message;
|
|
1913
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1914
1618
|
};
|
|
1915
1619
|
const deserializeAws_json1_1CreateTapeWithBarcodeCommand = async (output, context) => {
|
|
1916
1620
|
if (output.statusCode >= 300) {
|
|
@@ -1937,35 +1641,19 @@ const deserializeAws_json1_1CreateTapeWithBarcodeCommandError = async (output, c
|
|
|
1937
1641
|
switch (errorCode) {
|
|
1938
1642
|
case "InternalServerError":
|
|
1939
1643
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1940
|
-
|
|
1941
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1942
|
-
name: errorCode,
|
|
1943
|
-
$metadata: deserializeMetadata(output),
|
|
1944
|
-
};
|
|
1945
|
-
break;
|
|
1644
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
1946
1645
|
case "InvalidGatewayRequestException":
|
|
1947
1646
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
1948
|
-
|
|
1949
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
1950
|
-
name: errorCode,
|
|
1951
|
-
$metadata: deserializeMetadata(output),
|
|
1952
|
-
};
|
|
1953
|
-
break;
|
|
1647
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
1954
1648
|
default:
|
|
1955
1649
|
const parsedBody = parsedOutput.body;
|
|
1956
|
-
|
|
1957
|
-
|
|
1958
|
-
...parsedBody,
|
|
1959
|
-
name: `${errorCode}`,
|
|
1960
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1650
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1651
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
1961
1652
|
$fault: "client",
|
|
1962
1653
|
$metadata: deserializeMetadata(output),
|
|
1963
|
-
};
|
|
1654
|
+
});
|
|
1655
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
1964
1656
|
}
|
|
1965
|
-
const message = response.message || response.Message || errorCode;
|
|
1966
|
-
response.message = message;
|
|
1967
|
-
delete response.Message;
|
|
1968
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1969
1657
|
};
|
|
1970
1658
|
const deserializeAws_json1_1DeleteAutomaticTapeCreationPolicyCommand = async (output, context) => {
|
|
1971
1659
|
if (output.statusCode >= 300) {
|
|
@@ -1992,35 +1680,19 @@ const deserializeAws_json1_1DeleteAutomaticTapeCreationPolicyCommandError = asyn
|
|
|
1992
1680
|
switch (errorCode) {
|
|
1993
1681
|
case "InternalServerError":
|
|
1994
1682
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
1995
|
-
|
|
1996
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
1997
|
-
name: errorCode,
|
|
1998
|
-
$metadata: deserializeMetadata(output),
|
|
1999
|
-
};
|
|
2000
|
-
break;
|
|
1683
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2001
1684
|
case "InvalidGatewayRequestException":
|
|
2002
1685
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2003
|
-
|
|
2004
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2005
|
-
name: errorCode,
|
|
2006
|
-
$metadata: deserializeMetadata(output),
|
|
2007
|
-
};
|
|
2008
|
-
break;
|
|
1686
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2009
1687
|
default:
|
|
2010
1688
|
const parsedBody = parsedOutput.body;
|
|
2011
|
-
|
|
2012
|
-
|
|
2013
|
-
...parsedBody,
|
|
2014
|
-
name: `${errorCode}`,
|
|
2015
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1689
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1690
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2016
1691
|
$fault: "client",
|
|
2017
1692
|
$metadata: deserializeMetadata(output),
|
|
2018
|
-
};
|
|
1693
|
+
});
|
|
1694
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2019
1695
|
}
|
|
2020
|
-
const message = response.message || response.Message || errorCode;
|
|
2021
|
-
response.message = message;
|
|
2022
|
-
delete response.Message;
|
|
2023
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2024
1696
|
};
|
|
2025
1697
|
const deserializeAws_json1_1DeleteBandwidthRateLimitCommand = async (output, context) => {
|
|
2026
1698
|
if (output.statusCode >= 300) {
|
|
@@ -2047,35 +1719,19 @@ const deserializeAws_json1_1DeleteBandwidthRateLimitCommandError = async (output
|
|
|
2047
1719
|
switch (errorCode) {
|
|
2048
1720
|
case "InternalServerError":
|
|
2049
1721
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2050
|
-
|
|
2051
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2052
|
-
name: errorCode,
|
|
2053
|
-
$metadata: deserializeMetadata(output),
|
|
2054
|
-
};
|
|
2055
|
-
break;
|
|
1722
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2056
1723
|
case "InvalidGatewayRequestException":
|
|
2057
1724
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2058
|
-
|
|
2059
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2060
|
-
name: errorCode,
|
|
2061
|
-
$metadata: deserializeMetadata(output),
|
|
2062
|
-
};
|
|
2063
|
-
break;
|
|
1725
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2064
1726
|
default:
|
|
2065
1727
|
const parsedBody = parsedOutput.body;
|
|
2066
|
-
|
|
2067
|
-
|
|
2068
|
-
...parsedBody,
|
|
2069
|
-
name: `${errorCode}`,
|
|
2070
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1728
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1729
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2071
1730
|
$fault: "client",
|
|
2072
1731
|
$metadata: deserializeMetadata(output),
|
|
2073
|
-
};
|
|
1732
|
+
});
|
|
1733
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2074
1734
|
}
|
|
2075
|
-
const message = response.message || response.Message || errorCode;
|
|
2076
|
-
response.message = message;
|
|
2077
|
-
delete response.Message;
|
|
2078
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2079
1735
|
};
|
|
2080
1736
|
const deserializeAws_json1_1DeleteChapCredentialsCommand = async (output, context) => {
|
|
2081
1737
|
if (output.statusCode >= 300) {
|
|
@@ -2102,35 +1758,19 @@ const deserializeAws_json1_1DeleteChapCredentialsCommandError = async (output, c
|
|
|
2102
1758
|
switch (errorCode) {
|
|
2103
1759
|
case "InternalServerError":
|
|
2104
1760
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2105
|
-
|
|
2106
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2107
|
-
name: errorCode,
|
|
2108
|
-
$metadata: deserializeMetadata(output),
|
|
2109
|
-
};
|
|
2110
|
-
break;
|
|
1761
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2111
1762
|
case "InvalidGatewayRequestException":
|
|
2112
1763
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2113
|
-
|
|
2114
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2115
|
-
name: errorCode,
|
|
2116
|
-
$metadata: deserializeMetadata(output),
|
|
2117
|
-
};
|
|
2118
|
-
break;
|
|
1764
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2119
1765
|
default:
|
|
2120
1766
|
const parsedBody = parsedOutput.body;
|
|
2121
|
-
|
|
2122
|
-
|
|
2123
|
-
...parsedBody,
|
|
2124
|
-
name: `${errorCode}`,
|
|
2125
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1767
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1768
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2126
1769
|
$fault: "client",
|
|
2127
1770
|
$metadata: deserializeMetadata(output),
|
|
2128
|
-
};
|
|
1771
|
+
});
|
|
1772
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2129
1773
|
}
|
|
2130
|
-
const message = response.message || response.Message || errorCode;
|
|
2131
|
-
response.message = message;
|
|
2132
|
-
delete response.Message;
|
|
2133
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2134
1774
|
};
|
|
2135
1775
|
const deserializeAws_json1_1DeleteFileShareCommand = async (output, context) => {
|
|
2136
1776
|
if (output.statusCode >= 300) {
|
|
@@ -2157,35 +1797,19 @@ const deserializeAws_json1_1DeleteFileShareCommandError = async (output, context
|
|
|
2157
1797
|
switch (errorCode) {
|
|
2158
1798
|
case "InternalServerError":
|
|
2159
1799
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2160
|
-
|
|
2161
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2162
|
-
name: errorCode,
|
|
2163
|
-
$metadata: deserializeMetadata(output),
|
|
2164
|
-
};
|
|
2165
|
-
break;
|
|
1800
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2166
1801
|
case "InvalidGatewayRequestException":
|
|
2167
1802
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2168
|
-
|
|
2169
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2170
|
-
name: errorCode,
|
|
2171
|
-
$metadata: deserializeMetadata(output),
|
|
2172
|
-
};
|
|
2173
|
-
break;
|
|
1803
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2174
1804
|
default:
|
|
2175
1805
|
const parsedBody = parsedOutput.body;
|
|
2176
|
-
|
|
2177
|
-
|
|
2178
|
-
...parsedBody,
|
|
2179
|
-
name: `${errorCode}`,
|
|
2180
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1806
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1807
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2181
1808
|
$fault: "client",
|
|
2182
1809
|
$metadata: deserializeMetadata(output),
|
|
2183
|
-
};
|
|
1810
|
+
});
|
|
1811
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2184
1812
|
}
|
|
2185
|
-
const message = response.message || response.Message || errorCode;
|
|
2186
|
-
response.message = message;
|
|
2187
|
-
delete response.Message;
|
|
2188
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2189
1813
|
};
|
|
2190
1814
|
const deserializeAws_json1_1DeleteGatewayCommand = async (output, context) => {
|
|
2191
1815
|
if (output.statusCode >= 300) {
|
|
@@ -2212,35 +1836,19 @@ const deserializeAws_json1_1DeleteGatewayCommandError = async (output, context)
|
|
|
2212
1836
|
switch (errorCode) {
|
|
2213
1837
|
case "InternalServerError":
|
|
2214
1838
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2215
|
-
|
|
2216
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2217
|
-
name: errorCode,
|
|
2218
|
-
$metadata: deserializeMetadata(output),
|
|
2219
|
-
};
|
|
2220
|
-
break;
|
|
1839
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2221
1840
|
case "InvalidGatewayRequestException":
|
|
2222
1841
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2223
|
-
|
|
2224
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2225
|
-
name: errorCode,
|
|
2226
|
-
$metadata: deserializeMetadata(output),
|
|
2227
|
-
};
|
|
2228
|
-
break;
|
|
1842
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2229
1843
|
default:
|
|
2230
1844
|
const parsedBody = parsedOutput.body;
|
|
2231
|
-
|
|
2232
|
-
|
|
2233
|
-
...parsedBody,
|
|
2234
|
-
name: `${errorCode}`,
|
|
2235
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1845
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1846
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2236
1847
|
$fault: "client",
|
|
2237
1848
|
$metadata: deserializeMetadata(output),
|
|
2238
|
-
};
|
|
1849
|
+
});
|
|
1850
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2239
1851
|
}
|
|
2240
|
-
const message = response.message || response.Message || errorCode;
|
|
2241
|
-
response.message = message;
|
|
2242
|
-
delete response.Message;
|
|
2243
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2244
1852
|
};
|
|
2245
1853
|
const deserializeAws_json1_1DeleteSnapshotScheduleCommand = async (output, context) => {
|
|
2246
1854
|
if (output.statusCode >= 300) {
|
|
@@ -2267,35 +1875,19 @@ const deserializeAws_json1_1DeleteSnapshotScheduleCommandError = async (output,
|
|
|
2267
1875
|
switch (errorCode) {
|
|
2268
1876
|
case "InternalServerError":
|
|
2269
1877
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2270
|
-
|
|
2271
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2272
|
-
name: errorCode,
|
|
2273
|
-
$metadata: deserializeMetadata(output),
|
|
2274
|
-
};
|
|
2275
|
-
break;
|
|
1878
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2276
1879
|
case "InvalidGatewayRequestException":
|
|
2277
1880
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2278
|
-
|
|
2279
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2280
|
-
name: errorCode,
|
|
2281
|
-
$metadata: deserializeMetadata(output),
|
|
2282
|
-
};
|
|
2283
|
-
break;
|
|
1881
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2284
1882
|
default:
|
|
2285
1883
|
const parsedBody = parsedOutput.body;
|
|
2286
|
-
|
|
2287
|
-
|
|
2288
|
-
...parsedBody,
|
|
2289
|
-
name: `${errorCode}`,
|
|
2290
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1884
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1885
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2291
1886
|
$fault: "client",
|
|
2292
1887
|
$metadata: deserializeMetadata(output),
|
|
2293
|
-
};
|
|
1888
|
+
});
|
|
1889
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2294
1890
|
}
|
|
2295
|
-
const message = response.message || response.Message || errorCode;
|
|
2296
|
-
response.message = message;
|
|
2297
|
-
delete response.Message;
|
|
2298
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2299
1891
|
};
|
|
2300
1892
|
const deserializeAws_json1_1DeleteTapeCommand = async (output, context) => {
|
|
2301
1893
|
if (output.statusCode >= 300) {
|
|
@@ -2322,35 +1914,19 @@ const deserializeAws_json1_1DeleteTapeCommandError = async (output, context) =>
|
|
|
2322
1914
|
switch (errorCode) {
|
|
2323
1915
|
case "InternalServerError":
|
|
2324
1916
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2325
|
-
|
|
2326
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2327
|
-
name: errorCode,
|
|
2328
|
-
$metadata: deserializeMetadata(output),
|
|
2329
|
-
};
|
|
2330
|
-
break;
|
|
1917
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2331
1918
|
case "InvalidGatewayRequestException":
|
|
2332
1919
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2333
|
-
|
|
2334
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2335
|
-
name: errorCode,
|
|
2336
|
-
$metadata: deserializeMetadata(output),
|
|
2337
|
-
};
|
|
2338
|
-
break;
|
|
1920
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2339
1921
|
default:
|
|
2340
1922
|
const parsedBody = parsedOutput.body;
|
|
2341
|
-
|
|
2342
|
-
|
|
2343
|
-
...parsedBody,
|
|
2344
|
-
name: `${errorCode}`,
|
|
2345
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1923
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1924
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2346
1925
|
$fault: "client",
|
|
2347
1926
|
$metadata: deserializeMetadata(output),
|
|
2348
|
-
};
|
|
1927
|
+
});
|
|
1928
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2349
1929
|
}
|
|
2350
|
-
const message = response.message || response.Message || errorCode;
|
|
2351
|
-
response.message = message;
|
|
2352
|
-
delete response.Message;
|
|
2353
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2354
1930
|
};
|
|
2355
1931
|
const deserializeAws_json1_1DeleteTapeArchiveCommand = async (output, context) => {
|
|
2356
1932
|
if (output.statusCode >= 300) {
|
|
@@ -2377,35 +1953,19 @@ const deserializeAws_json1_1DeleteTapeArchiveCommandError = async (output, conte
|
|
|
2377
1953
|
switch (errorCode) {
|
|
2378
1954
|
case "InternalServerError":
|
|
2379
1955
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2380
|
-
|
|
2381
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2382
|
-
name: errorCode,
|
|
2383
|
-
$metadata: deserializeMetadata(output),
|
|
2384
|
-
};
|
|
2385
|
-
break;
|
|
1956
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2386
1957
|
case "InvalidGatewayRequestException":
|
|
2387
1958
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2388
|
-
|
|
2389
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2390
|
-
name: errorCode,
|
|
2391
|
-
$metadata: deserializeMetadata(output),
|
|
2392
|
-
};
|
|
2393
|
-
break;
|
|
1959
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2394
1960
|
default:
|
|
2395
1961
|
const parsedBody = parsedOutput.body;
|
|
2396
|
-
|
|
2397
|
-
|
|
2398
|
-
...parsedBody,
|
|
2399
|
-
name: `${errorCode}`,
|
|
2400
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
1962
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
1963
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2401
1964
|
$fault: "client",
|
|
2402
1965
|
$metadata: deserializeMetadata(output),
|
|
2403
|
-
};
|
|
1966
|
+
});
|
|
1967
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2404
1968
|
}
|
|
2405
|
-
const message = response.message || response.Message || errorCode;
|
|
2406
|
-
response.message = message;
|
|
2407
|
-
delete response.Message;
|
|
2408
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2409
1969
|
};
|
|
2410
1970
|
const deserializeAws_json1_1DeleteTapePoolCommand = async (output, context) => {
|
|
2411
1971
|
if (output.statusCode >= 300) {
|
|
@@ -2432,35 +1992,19 @@ const deserializeAws_json1_1DeleteTapePoolCommandError = async (output, context)
|
|
|
2432
1992
|
switch (errorCode) {
|
|
2433
1993
|
case "InternalServerError":
|
|
2434
1994
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2435
|
-
|
|
2436
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2437
|
-
name: errorCode,
|
|
2438
|
-
$metadata: deserializeMetadata(output),
|
|
2439
|
-
};
|
|
2440
|
-
break;
|
|
1995
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2441
1996
|
case "InvalidGatewayRequestException":
|
|
2442
1997
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2443
|
-
|
|
2444
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2445
|
-
name: errorCode,
|
|
2446
|
-
$metadata: deserializeMetadata(output),
|
|
2447
|
-
};
|
|
2448
|
-
break;
|
|
1998
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2449
1999
|
default:
|
|
2450
2000
|
const parsedBody = parsedOutput.body;
|
|
2451
|
-
|
|
2452
|
-
|
|
2453
|
-
...parsedBody,
|
|
2454
|
-
name: `${errorCode}`,
|
|
2455
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2001
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2002
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2456
2003
|
$fault: "client",
|
|
2457
2004
|
$metadata: deserializeMetadata(output),
|
|
2458
|
-
};
|
|
2005
|
+
});
|
|
2006
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2459
2007
|
}
|
|
2460
|
-
const message = response.message || response.Message || errorCode;
|
|
2461
|
-
response.message = message;
|
|
2462
|
-
delete response.Message;
|
|
2463
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2464
2008
|
};
|
|
2465
2009
|
const deserializeAws_json1_1DeleteVolumeCommand = async (output, context) => {
|
|
2466
2010
|
if (output.statusCode >= 300) {
|
|
@@ -2487,35 +2031,19 @@ const deserializeAws_json1_1DeleteVolumeCommandError = async (output, context) =
|
|
|
2487
2031
|
switch (errorCode) {
|
|
2488
2032
|
case "InternalServerError":
|
|
2489
2033
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2490
|
-
|
|
2491
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2492
|
-
name: errorCode,
|
|
2493
|
-
$metadata: deserializeMetadata(output),
|
|
2494
|
-
};
|
|
2495
|
-
break;
|
|
2034
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2496
2035
|
case "InvalidGatewayRequestException":
|
|
2497
2036
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2498
|
-
|
|
2499
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2500
|
-
name: errorCode,
|
|
2501
|
-
$metadata: deserializeMetadata(output),
|
|
2502
|
-
};
|
|
2503
|
-
break;
|
|
2037
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2504
2038
|
default:
|
|
2505
2039
|
const parsedBody = parsedOutput.body;
|
|
2506
|
-
|
|
2507
|
-
|
|
2508
|
-
...parsedBody,
|
|
2509
|
-
name: `${errorCode}`,
|
|
2510
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2040
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2041
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2511
2042
|
$fault: "client",
|
|
2512
2043
|
$metadata: deserializeMetadata(output),
|
|
2513
|
-
};
|
|
2044
|
+
});
|
|
2045
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2514
2046
|
}
|
|
2515
|
-
const message = response.message || response.Message || errorCode;
|
|
2516
|
-
response.message = message;
|
|
2517
|
-
delete response.Message;
|
|
2518
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2519
2047
|
};
|
|
2520
2048
|
const deserializeAws_json1_1DescribeAvailabilityMonitorTestCommand = async (output, context) => {
|
|
2521
2049
|
if (output.statusCode >= 300) {
|
|
@@ -2542,35 +2070,19 @@ const deserializeAws_json1_1DescribeAvailabilityMonitorTestCommandError = async
|
|
|
2542
2070
|
switch (errorCode) {
|
|
2543
2071
|
case "InternalServerError":
|
|
2544
2072
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2545
|
-
|
|
2546
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2547
|
-
name: errorCode,
|
|
2548
|
-
$metadata: deserializeMetadata(output),
|
|
2549
|
-
};
|
|
2550
|
-
break;
|
|
2073
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2551
2074
|
case "InvalidGatewayRequestException":
|
|
2552
2075
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2553
|
-
|
|
2554
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2555
|
-
name: errorCode,
|
|
2556
|
-
$metadata: deserializeMetadata(output),
|
|
2557
|
-
};
|
|
2558
|
-
break;
|
|
2076
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2559
2077
|
default:
|
|
2560
2078
|
const parsedBody = parsedOutput.body;
|
|
2561
|
-
|
|
2562
|
-
|
|
2563
|
-
...parsedBody,
|
|
2564
|
-
name: `${errorCode}`,
|
|
2565
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2079
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2080
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2566
2081
|
$fault: "client",
|
|
2567
2082
|
$metadata: deserializeMetadata(output),
|
|
2568
|
-
};
|
|
2083
|
+
});
|
|
2084
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2569
2085
|
}
|
|
2570
|
-
const message = response.message || response.Message || errorCode;
|
|
2571
|
-
response.message = message;
|
|
2572
|
-
delete response.Message;
|
|
2573
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2574
2086
|
};
|
|
2575
2087
|
const deserializeAws_json1_1DescribeBandwidthRateLimitCommand = async (output, context) => {
|
|
2576
2088
|
if (output.statusCode >= 300) {
|
|
@@ -2597,35 +2109,19 @@ const deserializeAws_json1_1DescribeBandwidthRateLimitCommandError = async (outp
|
|
|
2597
2109
|
switch (errorCode) {
|
|
2598
2110
|
case "InternalServerError":
|
|
2599
2111
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2600
|
-
|
|
2601
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2602
|
-
name: errorCode,
|
|
2603
|
-
$metadata: deserializeMetadata(output),
|
|
2604
|
-
};
|
|
2605
|
-
break;
|
|
2112
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2606
2113
|
case "InvalidGatewayRequestException":
|
|
2607
2114
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2608
|
-
|
|
2609
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2610
|
-
name: errorCode,
|
|
2611
|
-
$metadata: deserializeMetadata(output),
|
|
2612
|
-
};
|
|
2613
|
-
break;
|
|
2115
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2614
2116
|
default:
|
|
2615
2117
|
const parsedBody = parsedOutput.body;
|
|
2616
|
-
|
|
2617
|
-
|
|
2618
|
-
...parsedBody,
|
|
2619
|
-
name: `${errorCode}`,
|
|
2620
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2118
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2119
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2621
2120
|
$fault: "client",
|
|
2622
2121
|
$metadata: deserializeMetadata(output),
|
|
2623
|
-
};
|
|
2122
|
+
});
|
|
2123
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2624
2124
|
}
|
|
2625
|
-
const message = response.message || response.Message || errorCode;
|
|
2626
|
-
response.message = message;
|
|
2627
|
-
delete response.Message;
|
|
2628
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2629
2125
|
};
|
|
2630
2126
|
const deserializeAws_json1_1DescribeBandwidthRateLimitScheduleCommand = async (output, context) => {
|
|
2631
2127
|
if (output.statusCode >= 300) {
|
|
@@ -2652,35 +2148,19 @@ const deserializeAws_json1_1DescribeBandwidthRateLimitScheduleCommandError = asy
|
|
|
2652
2148
|
switch (errorCode) {
|
|
2653
2149
|
case "InternalServerError":
|
|
2654
2150
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2655
|
-
|
|
2656
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2657
|
-
name: errorCode,
|
|
2658
|
-
$metadata: deserializeMetadata(output),
|
|
2659
|
-
};
|
|
2660
|
-
break;
|
|
2151
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2661
2152
|
case "InvalidGatewayRequestException":
|
|
2662
2153
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2663
|
-
|
|
2664
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2665
|
-
name: errorCode,
|
|
2666
|
-
$metadata: deserializeMetadata(output),
|
|
2667
|
-
};
|
|
2668
|
-
break;
|
|
2154
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2669
2155
|
default:
|
|
2670
2156
|
const parsedBody = parsedOutput.body;
|
|
2671
|
-
|
|
2672
|
-
|
|
2673
|
-
...parsedBody,
|
|
2674
|
-
name: `${errorCode}`,
|
|
2675
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2157
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2158
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2676
2159
|
$fault: "client",
|
|
2677
2160
|
$metadata: deserializeMetadata(output),
|
|
2678
|
-
};
|
|
2161
|
+
});
|
|
2162
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2679
2163
|
}
|
|
2680
|
-
const message = response.message || response.Message || errorCode;
|
|
2681
|
-
response.message = message;
|
|
2682
|
-
delete response.Message;
|
|
2683
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2684
2164
|
};
|
|
2685
2165
|
const deserializeAws_json1_1DescribeCacheCommand = async (output, context) => {
|
|
2686
2166
|
if (output.statusCode >= 300) {
|
|
@@ -2707,35 +2187,19 @@ const deserializeAws_json1_1DescribeCacheCommandError = async (output, context)
|
|
|
2707
2187
|
switch (errorCode) {
|
|
2708
2188
|
case "InternalServerError":
|
|
2709
2189
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2710
|
-
|
|
2711
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2712
|
-
name: errorCode,
|
|
2713
|
-
$metadata: deserializeMetadata(output),
|
|
2714
|
-
};
|
|
2715
|
-
break;
|
|
2190
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2716
2191
|
case "InvalidGatewayRequestException":
|
|
2717
2192
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2718
|
-
|
|
2719
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2720
|
-
name: errorCode,
|
|
2721
|
-
$metadata: deserializeMetadata(output),
|
|
2722
|
-
};
|
|
2723
|
-
break;
|
|
2193
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2724
2194
|
default:
|
|
2725
2195
|
const parsedBody = parsedOutput.body;
|
|
2726
|
-
|
|
2727
|
-
|
|
2728
|
-
...parsedBody,
|
|
2729
|
-
name: `${errorCode}`,
|
|
2730
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2196
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2197
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2731
2198
|
$fault: "client",
|
|
2732
2199
|
$metadata: deserializeMetadata(output),
|
|
2733
|
-
};
|
|
2200
|
+
});
|
|
2201
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2734
2202
|
}
|
|
2735
|
-
const message = response.message || response.Message || errorCode;
|
|
2736
|
-
response.message = message;
|
|
2737
|
-
delete response.Message;
|
|
2738
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2739
2203
|
};
|
|
2740
2204
|
const deserializeAws_json1_1DescribeCachediSCSIVolumesCommand = async (output, context) => {
|
|
2741
2205
|
if (output.statusCode >= 300) {
|
|
@@ -2762,35 +2226,19 @@ const deserializeAws_json1_1DescribeCachediSCSIVolumesCommandError = async (outp
|
|
|
2762
2226
|
switch (errorCode) {
|
|
2763
2227
|
case "InternalServerError":
|
|
2764
2228
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2765
|
-
|
|
2766
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2767
|
-
name: errorCode,
|
|
2768
|
-
$metadata: deserializeMetadata(output),
|
|
2769
|
-
};
|
|
2770
|
-
break;
|
|
2229
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2771
2230
|
case "InvalidGatewayRequestException":
|
|
2772
2231
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2773
|
-
|
|
2774
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2775
|
-
name: errorCode,
|
|
2776
|
-
$metadata: deserializeMetadata(output),
|
|
2777
|
-
};
|
|
2778
|
-
break;
|
|
2232
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2779
2233
|
default:
|
|
2780
2234
|
const parsedBody = parsedOutput.body;
|
|
2781
|
-
|
|
2782
|
-
|
|
2783
|
-
...parsedBody,
|
|
2784
|
-
name: `${errorCode}`,
|
|
2785
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2235
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2236
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2786
2237
|
$fault: "client",
|
|
2787
2238
|
$metadata: deserializeMetadata(output),
|
|
2788
|
-
};
|
|
2239
|
+
});
|
|
2240
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2789
2241
|
}
|
|
2790
|
-
const message = response.message || response.Message || errorCode;
|
|
2791
|
-
response.message = message;
|
|
2792
|
-
delete response.Message;
|
|
2793
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2794
2242
|
};
|
|
2795
2243
|
const deserializeAws_json1_1DescribeChapCredentialsCommand = async (output, context) => {
|
|
2796
2244
|
if (output.statusCode >= 300) {
|
|
@@ -2817,35 +2265,19 @@ const deserializeAws_json1_1DescribeChapCredentialsCommandError = async (output,
|
|
|
2817
2265
|
switch (errorCode) {
|
|
2818
2266
|
case "InternalServerError":
|
|
2819
2267
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2820
|
-
|
|
2821
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2822
|
-
name: errorCode,
|
|
2823
|
-
$metadata: deserializeMetadata(output),
|
|
2824
|
-
};
|
|
2825
|
-
break;
|
|
2268
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2826
2269
|
case "InvalidGatewayRequestException":
|
|
2827
2270
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2828
|
-
|
|
2829
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2830
|
-
name: errorCode,
|
|
2831
|
-
$metadata: deserializeMetadata(output),
|
|
2832
|
-
};
|
|
2833
|
-
break;
|
|
2271
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2834
2272
|
default:
|
|
2835
2273
|
const parsedBody = parsedOutput.body;
|
|
2836
|
-
|
|
2837
|
-
|
|
2838
|
-
...parsedBody,
|
|
2839
|
-
name: `${errorCode}`,
|
|
2840
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2274
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2275
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2841
2276
|
$fault: "client",
|
|
2842
2277
|
$metadata: deserializeMetadata(output),
|
|
2843
|
-
};
|
|
2278
|
+
});
|
|
2279
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2844
2280
|
}
|
|
2845
|
-
const message = response.message || response.Message || errorCode;
|
|
2846
|
-
response.message = message;
|
|
2847
|
-
delete response.Message;
|
|
2848
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2849
2281
|
};
|
|
2850
2282
|
const deserializeAws_json1_1DescribeFileSystemAssociationsCommand = async (output, context) => {
|
|
2851
2283
|
if (output.statusCode >= 300) {
|
|
@@ -2872,35 +2304,19 @@ const deserializeAws_json1_1DescribeFileSystemAssociationsCommandError = async (
|
|
|
2872
2304
|
switch (errorCode) {
|
|
2873
2305
|
case "InternalServerError":
|
|
2874
2306
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2875
|
-
|
|
2876
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2877
|
-
name: errorCode,
|
|
2878
|
-
$metadata: deserializeMetadata(output),
|
|
2879
|
-
};
|
|
2880
|
-
break;
|
|
2307
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2881
2308
|
case "InvalidGatewayRequestException":
|
|
2882
2309
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2883
|
-
|
|
2884
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2885
|
-
name: errorCode,
|
|
2886
|
-
$metadata: deserializeMetadata(output),
|
|
2887
|
-
};
|
|
2888
|
-
break;
|
|
2310
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2889
2311
|
default:
|
|
2890
2312
|
const parsedBody = parsedOutput.body;
|
|
2891
|
-
|
|
2892
|
-
|
|
2893
|
-
...parsedBody,
|
|
2894
|
-
name: `${errorCode}`,
|
|
2895
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2313
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2314
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2896
2315
|
$fault: "client",
|
|
2897
2316
|
$metadata: deserializeMetadata(output),
|
|
2898
|
-
};
|
|
2317
|
+
});
|
|
2318
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2899
2319
|
}
|
|
2900
|
-
const message = response.message || response.Message || errorCode;
|
|
2901
|
-
response.message = message;
|
|
2902
|
-
delete response.Message;
|
|
2903
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2904
2320
|
};
|
|
2905
2321
|
const deserializeAws_json1_1DescribeGatewayInformationCommand = async (output, context) => {
|
|
2906
2322
|
if (output.statusCode >= 300) {
|
|
@@ -2927,35 +2343,19 @@ const deserializeAws_json1_1DescribeGatewayInformationCommandError = async (outp
|
|
|
2927
2343
|
switch (errorCode) {
|
|
2928
2344
|
case "InternalServerError":
|
|
2929
2345
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2930
|
-
|
|
2931
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2932
|
-
name: errorCode,
|
|
2933
|
-
$metadata: deserializeMetadata(output),
|
|
2934
|
-
};
|
|
2935
|
-
break;
|
|
2346
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2936
2347
|
case "InvalidGatewayRequestException":
|
|
2937
2348
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2938
|
-
|
|
2939
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2940
|
-
name: errorCode,
|
|
2941
|
-
$metadata: deserializeMetadata(output),
|
|
2942
|
-
};
|
|
2943
|
-
break;
|
|
2349
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2944
2350
|
default:
|
|
2945
2351
|
const parsedBody = parsedOutput.body;
|
|
2946
|
-
|
|
2947
|
-
|
|
2948
|
-
...parsedBody,
|
|
2949
|
-
name: `${errorCode}`,
|
|
2950
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2352
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2353
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
2951
2354
|
$fault: "client",
|
|
2952
2355
|
$metadata: deserializeMetadata(output),
|
|
2953
|
-
};
|
|
2356
|
+
});
|
|
2357
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
2954
2358
|
}
|
|
2955
|
-
const message = response.message || response.Message || errorCode;
|
|
2956
|
-
response.message = message;
|
|
2957
|
-
delete response.Message;
|
|
2958
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2959
2359
|
};
|
|
2960
2360
|
const deserializeAws_json1_1DescribeMaintenanceStartTimeCommand = async (output, context) => {
|
|
2961
2361
|
if (output.statusCode >= 300) {
|
|
@@ -2982,35 +2382,19 @@ const deserializeAws_json1_1DescribeMaintenanceStartTimeCommandError = async (ou
|
|
|
2982
2382
|
switch (errorCode) {
|
|
2983
2383
|
case "InternalServerError":
|
|
2984
2384
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
2985
|
-
|
|
2986
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
2987
|
-
name: errorCode,
|
|
2988
|
-
$metadata: deserializeMetadata(output),
|
|
2989
|
-
};
|
|
2990
|
-
break;
|
|
2385
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
2991
2386
|
case "InvalidGatewayRequestException":
|
|
2992
2387
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
2993
|
-
|
|
2994
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
2995
|
-
name: errorCode,
|
|
2996
|
-
$metadata: deserializeMetadata(output),
|
|
2997
|
-
};
|
|
2998
|
-
break;
|
|
2388
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
2999
2389
|
default:
|
|
3000
2390
|
const parsedBody = parsedOutput.body;
|
|
3001
|
-
|
|
3002
|
-
|
|
3003
|
-
...parsedBody,
|
|
3004
|
-
name: `${errorCode}`,
|
|
3005
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2391
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2392
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3006
2393
|
$fault: "client",
|
|
3007
2394
|
$metadata: deserializeMetadata(output),
|
|
3008
|
-
};
|
|
2395
|
+
});
|
|
2396
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3009
2397
|
}
|
|
3010
|
-
const message = response.message || response.Message || errorCode;
|
|
3011
|
-
response.message = message;
|
|
3012
|
-
delete response.Message;
|
|
3013
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3014
2398
|
};
|
|
3015
2399
|
const deserializeAws_json1_1DescribeNFSFileSharesCommand = async (output, context) => {
|
|
3016
2400
|
if (output.statusCode >= 300) {
|
|
@@ -3037,35 +2421,19 @@ const deserializeAws_json1_1DescribeNFSFileSharesCommandError = async (output, c
|
|
|
3037
2421
|
switch (errorCode) {
|
|
3038
2422
|
case "InternalServerError":
|
|
3039
2423
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3040
|
-
|
|
3041
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3042
|
-
name: errorCode,
|
|
3043
|
-
$metadata: deserializeMetadata(output),
|
|
3044
|
-
};
|
|
3045
|
-
break;
|
|
2424
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3046
2425
|
case "InvalidGatewayRequestException":
|
|
3047
2426
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3048
|
-
|
|
3049
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3050
|
-
name: errorCode,
|
|
3051
|
-
$metadata: deserializeMetadata(output),
|
|
3052
|
-
};
|
|
3053
|
-
break;
|
|
2427
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3054
2428
|
default:
|
|
3055
2429
|
const parsedBody = parsedOutput.body;
|
|
3056
|
-
|
|
3057
|
-
|
|
3058
|
-
...parsedBody,
|
|
3059
|
-
name: `${errorCode}`,
|
|
3060
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2430
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2431
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3061
2432
|
$fault: "client",
|
|
3062
2433
|
$metadata: deserializeMetadata(output),
|
|
3063
|
-
};
|
|
2434
|
+
});
|
|
2435
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3064
2436
|
}
|
|
3065
|
-
const message = response.message || response.Message || errorCode;
|
|
3066
|
-
response.message = message;
|
|
3067
|
-
delete response.Message;
|
|
3068
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3069
2437
|
};
|
|
3070
2438
|
const deserializeAws_json1_1DescribeSMBFileSharesCommand = async (output, context) => {
|
|
3071
2439
|
if (output.statusCode >= 300) {
|
|
@@ -3092,35 +2460,19 @@ const deserializeAws_json1_1DescribeSMBFileSharesCommandError = async (output, c
|
|
|
3092
2460
|
switch (errorCode) {
|
|
3093
2461
|
case "InternalServerError":
|
|
3094
2462
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3095
|
-
|
|
3096
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3097
|
-
name: errorCode,
|
|
3098
|
-
$metadata: deserializeMetadata(output),
|
|
3099
|
-
};
|
|
3100
|
-
break;
|
|
2463
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3101
2464
|
case "InvalidGatewayRequestException":
|
|
3102
2465
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3103
|
-
|
|
3104
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3105
|
-
name: errorCode,
|
|
3106
|
-
$metadata: deserializeMetadata(output),
|
|
3107
|
-
};
|
|
3108
|
-
break;
|
|
2466
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3109
2467
|
default:
|
|
3110
2468
|
const parsedBody = parsedOutput.body;
|
|
3111
|
-
|
|
3112
|
-
|
|
3113
|
-
...parsedBody,
|
|
3114
|
-
name: `${errorCode}`,
|
|
3115
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2469
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2470
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3116
2471
|
$fault: "client",
|
|
3117
2472
|
$metadata: deserializeMetadata(output),
|
|
3118
|
-
};
|
|
2473
|
+
});
|
|
2474
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3119
2475
|
}
|
|
3120
|
-
const message = response.message || response.Message || errorCode;
|
|
3121
|
-
response.message = message;
|
|
3122
|
-
delete response.Message;
|
|
3123
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3124
2476
|
};
|
|
3125
2477
|
const deserializeAws_json1_1DescribeSMBSettingsCommand = async (output, context) => {
|
|
3126
2478
|
if (output.statusCode >= 300) {
|
|
@@ -3147,35 +2499,19 @@ const deserializeAws_json1_1DescribeSMBSettingsCommandError = async (output, con
|
|
|
3147
2499
|
switch (errorCode) {
|
|
3148
2500
|
case "InternalServerError":
|
|
3149
2501
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3150
|
-
|
|
3151
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3152
|
-
name: errorCode,
|
|
3153
|
-
$metadata: deserializeMetadata(output),
|
|
3154
|
-
};
|
|
3155
|
-
break;
|
|
2502
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3156
2503
|
case "InvalidGatewayRequestException":
|
|
3157
2504
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3158
|
-
|
|
3159
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3160
|
-
name: errorCode,
|
|
3161
|
-
$metadata: deserializeMetadata(output),
|
|
3162
|
-
};
|
|
3163
|
-
break;
|
|
2505
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3164
2506
|
default:
|
|
3165
2507
|
const parsedBody = parsedOutput.body;
|
|
3166
|
-
|
|
3167
|
-
|
|
3168
|
-
...parsedBody,
|
|
3169
|
-
name: `${errorCode}`,
|
|
3170
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2508
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2509
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3171
2510
|
$fault: "client",
|
|
3172
2511
|
$metadata: deserializeMetadata(output),
|
|
3173
|
-
};
|
|
2512
|
+
});
|
|
2513
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3174
2514
|
}
|
|
3175
|
-
const message = response.message || response.Message || errorCode;
|
|
3176
|
-
response.message = message;
|
|
3177
|
-
delete response.Message;
|
|
3178
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3179
2515
|
};
|
|
3180
2516
|
const deserializeAws_json1_1DescribeSnapshotScheduleCommand = async (output, context) => {
|
|
3181
2517
|
if (output.statusCode >= 300) {
|
|
@@ -3202,35 +2538,19 @@ const deserializeAws_json1_1DescribeSnapshotScheduleCommandError = async (output
|
|
|
3202
2538
|
switch (errorCode) {
|
|
3203
2539
|
case "InternalServerError":
|
|
3204
2540
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3205
|
-
|
|
3206
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3207
|
-
name: errorCode,
|
|
3208
|
-
$metadata: deserializeMetadata(output),
|
|
3209
|
-
};
|
|
3210
|
-
break;
|
|
2541
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3211
2542
|
case "InvalidGatewayRequestException":
|
|
3212
2543
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3213
|
-
|
|
3214
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3215
|
-
name: errorCode,
|
|
3216
|
-
$metadata: deserializeMetadata(output),
|
|
3217
|
-
};
|
|
3218
|
-
break;
|
|
2544
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3219
2545
|
default:
|
|
3220
2546
|
const parsedBody = parsedOutput.body;
|
|
3221
|
-
|
|
3222
|
-
|
|
3223
|
-
...parsedBody,
|
|
3224
|
-
name: `${errorCode}`,
|
|
3225
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2547
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2548
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3226
2549
|
$fault: "client",
|
|
3227
2550
|
$metadata: deserializeMetadata(output),
|
|
3228
|
-
};
|
|
2551
|
+
});
|
|
2552
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3229
2553
|
}
|
|
3230
|
-
const message = response.message || response.Message || errorCode;
|
|
3231
|
-
response.message = message;
|
|
3232
|
-
delete response.Message;
|
|
3233
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3234
2554
|
};
|
|
3235
2555
|
const deserializeAws_json1_1DescribeStorediSCSIVolumesCommand = async (output, context) => {
|
|
3236
2556
|
if (output.statusCode >= 300) {
|
|
@@ -3257,35 +2577,19 @@ const deserializeAws_json1_1DescribeStorediSCSIVolumesCommandError = async (outp
|
|
|
3257
2577
|
switch (errorCode) {
|
|
3258
2578
|
case "InternalServerError":
|
|
3259
2579
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3260
|
-
|
|
3261
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3262
|
-
name: errorCode,
|
|
3263
|
-
$metadata: deserializeMetadata(output),
|
|
3264
|
-
};
|
|
3265
|
-
break;
|
|
2580
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3266
2581
|
case "InvalidGatewayRequestException":
|
|
3267
2582
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3268
|
-
|
|
3269
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3270
|
-
name: errorCode,
|
|
3271
|
-
$metadata: deserializeMetadata(output),
|
|
3272
|
-
};
|
|
3273
|
-
break;
|
|
2583
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3274
2584
|
default:
|
|
3275
2585
|
const parsedBody = parsedOutput.body;
|
|
3276
|
-
|
|
3277
|
-
|
|
3278
|
-
...parsedBody,
|
|
3279
|
-
name: `${errorCode}`,
|
|
3280
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2586
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2587
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3281
2588
|
$fault: "client",
|
|
3282
2589
|
$metadata: deserializeMetadata(output),
|
|
3283
|
-
};
|
|
2590
|
+
});
|
|
2591
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3284
2592
|
}
|
|
3285
|
-
const message = response.message || response.Message || errorCode;
|
|
3286
|
-
response.message = message;
|
|
3287
|
-
delete response.Message;
|
|
3288
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3289
2593
|
};
|
|
3290
2594
|
const deserializeAws_json1_1DescribeTapeArchivesCommand = async (output, context) => {
|
|
3291
2595
|
if (output.statusCode >= 300) {
|
|
@@ -3312,35 +2616,19 @@ const deserializeAws_json1_1DescribeTapeArchivesCommandError = async (output, co
|
|
|
3312
2616
|
switch (errorCode) {
|
|
3313
2617
|
case "InternalServerError":
|
|
3314
2618
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3315
|
-
|
|
3316
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3317
|
-
name: errorCode,
|
|
3318
|
-
$metadata: deserializeMetadata(output),
|
|
3319
|
-
};
|
|
3320
|
-
break;
|
|
2619
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3321
2620
|
case "InvalidGatewayRequestException":
|
|
3322
2621
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3323
|
-
|
|
3324
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3325
|
-
name: errorCode,
|
|
3326
|
-
$metadata: deserializeMetadata(output),
|
|
3327
|
-
};
|
|
3328
|
-
break;
|
|
2622
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3329
2623
|
default:
|
|
3330
2624
|
const parsedBody = parsedOutput.body;
|
|
3331
|
-
|
|
3332
|
-
|
|
3333
|
-
...parsedBody,
|
|
3334
|
-
name: `${errorCode}`,
|
|
3335
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2625
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2626
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3336
2627
|
$fault: "client",
|
|
3337
2628
|
$metadata: deserializeMetadata(output),
|
|
3338
|
-
};
|
|
2629
|
+
});
|
|
2630
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3339
2631
|
}
|
|
3340
|
-
const message = response.message || response.Message || errorCode;
|
|
3341
|
-
response.message = message;
|
|
3342
|
-
delete response.Message;
|
|
3343
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3344
2632
|
};
|
|
3345
2633
|
const deserializeAws_json1_1DescribeTapeRecoveryPointsCommand = async (output, context) => {
|
|
3346
2634
|
if (output.statusCode >= 300) {
|
|
@@ -3367,35 +2655,19 @@ const deserializeAws_json1_1DescribeTapeRecoveryPointsCommandError = async (outp
|
|
|
3367
2655
|
switch (errorCode) {
|
|
3368
2656
|
case "InternalServerError":
|
|
3369
2657
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3370
|
-
|
|
3371
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3372
|
-
name: errorCode,
|
|
3373
|
-
$metadata: deserializeMetadata(output),
|
|
3374
|
-
};
|
|
3375
|
-
break;
|
|
2658
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3376
2659
|
case "InvalidGatewayRequestException":
|
|
3377
2660
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3378
|
-
|
|
3379
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3380
|
-
name: errorCode,
|
|
3381
|
-
$metadata: deserializeMetadata(output),
|
|
3382
|
-
};
|
|
3383
|
-
break;
|
|
2661
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3384
2662
|
default:
|
|
3385
2663
|
const parsedBody = parsedOutput.body;
|
|
3386
|
-
|
|
3387
|
-
|
|
3388
|
-
...parsedBody,
|
|
3389
|
-
name: `${errorCode}`,
|
|
3390
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2664
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2665
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3391
2666
|
$fault: "client",
|
|
3392
2667
|
$metadata: deserializeMetadata(output),
|
|
3393
|
-
};
|
|
2668
|
+
});
|
|
2669
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3394
2670
|
}
|
|
3395
|
-
const message = response.message || response.Message || errorCode;
|
|
3396
|
-
response.message = message;
|
|
3397
|
-
delete response.Message;
|
|
3398
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3399
2671
|
};
|
|
3400
2672
|
const deserializeAws_json1_1DescribeTapesCommand = async (output, context) => {
|
|
3401
2673
|
if (output.statusCode >= 300) {
|
|
@@ -3422,35 +2694,19 @@ const deserializeAws_json1_1DescribeTapesCommandError = async (output, context)
|
|
|
3422
2694
|
switch (errorCode) {
|
|
3423
2695
|
case "InternalServerError":
|
|
3424
2696
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3425
|
-
|
|
3426
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3427
|
-
name: errorCode,
|
|
3428
|
-
$metadata: deserializeMetadata(output),
|
|
3429
|
-
};
|
|
3430
|
-
break;
|
|
2697
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3431
2698
|
case "InvalidGatewayRequestException":
|
|
3432
2699
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3433
|
-
|
|
3434
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3435
|
-
name: errorCode,
|
|
3436
|
-
$metadata: deserializeMetadata(output),
|
|
3437
|
-
};
|
|
3438
|
-
break;
|
|
2700
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3439
2701
|
default:
|
|
3440
2702
|
const parsedBody = parsedOutput.body;
|
|
3441
|
-
|
|
3442
|
-
|
|
3443
|
-
...parsedBody,
|
|
3444
|
-
name: `${errorCode}`,
|
|
3445
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2703
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2704
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3446
2705
|
$fault: "client",
|
|
3447
2706
|
$metadata: deserializeMetadata(output),
|
|
3448
|
-
};
|
|
2707
|
+
});
|
|
2708
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3449
2709
|
}
|
|
3450
|
-
const message = response.message || response.Message || errorCode;
|
|
3451
|
-
response.message = message;
|
|
3452
|
-
delete response.Message;
|
|
3453
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3454
2710
|
};
|
|
3455
2711
|
const deserializeAws_json1_1DescribeUploadBufferCommand = async (output, context) => {
|
|
3456
2712
|
if (output.statusCode >= 300) {
|
|
@@ -3477,35 +2733,19 @@ const deserializeAws_json1_1DescribeUploadBufferCommandError = async (output, co
|
|
|
3477
2733
|
switch (errorCode) {
|
|
3478
2734
|
case "InternalServerError":
|
|
3479
2735
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3480
|
-
|
|
3481
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3482
|
-
name: errorCode,
|
|
3483
|
-
$metadata: deserializeMetadata(output),
|
|
3484
|
-
};
|
|
3485
|
-
break;
|
|
2736
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3486
2737
|
case "InvalidGatewayRequestException":
|
|
3487
2738
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3488
|
-
|
|
3489
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3490
|
-
name: errorCode,
|
|
3491
|
-
$metadata: deserializeMetadata(output),
|
|
3492
|
-
};
|
|
3493
|
-
break;
|
|
2739
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3494
2740
|
default:
|
|
3495
2741
|
const parsedBody = parsedOutput.body;
|
|
3496
|
-
|
|
3497
|
-
|
|
3498
|
-
...parsedBody,
|
|
3499
|
-
name: `${errorCode}`,
|
|
3500
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2742
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2743
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3501
2744
|
$fault: "client",
|
|
3502
2745
|
$metadata: deserializeMetadata(output),
|
|
3503
|
-
};
|
|
2746
|
+
});
|
|
2747
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3504
2748
|
}
|
|
3505
|
-
const message = response.message || response.Message || errorCode;
|
|
3506
|
-
response.message = message;
|
|
3507
|
-
delete response.Message;
|
|
3508
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3509
2749
|
};
|
|
3510
2750
|
const deserializeAws_json1_1DescribeVTLDevicesCommand = async (output, context) => {
|
|
3511
2751
|
if (output.statusCode >= 300) {
|
|
@@ -3532,35 +2772,19 @@ const deserializeAws_json1_1DescribeVTLDevicesCommandError = async (output, cont
|
|
|
3532
2772
|
switch (errorCode) {
|
|
3533
2773
|
case "InternalServerError":
|
|
3534
2774
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3535
|
-
|
|
3536
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3537
|
-
name: errorCode,
|
|
3538
|
-
$metadata: deserializeMetadata(output),
|
|
3539
|
-
};
|
|
3540
|
-
break;
|
|
2775
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3541
2776
|
case "InvalidGatewayRequestException":
|
|
3542
2777
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3543
|
-
|
|
3544
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3545
|
-
name: errorCode,
|
|
3546
|
-
$metadata: deserializeMetadata(output),
|
|
3547
|
-
};
|
|
3548
|
-
break;
|
|
2778
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3549
2779
|
default:
|
|
3550
2780
|
const parsedBody = parsedOutput.body;
|
|
3551
|
-
|
|
3552
|
-
|
|
3553
|
-
...parsedBody,
|
|
3554
|
-
name: `${errorCode}`,
|
|
3555
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2781
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2782
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3556
2783
|
$fault: "client",
|
|
3557
2784
|
$metadata: deserializeMetadata(output),
|
|
3558
|
-
};
|
|
2785
|
+
});
|
|
2786
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3559
2787
|
}
|
|
3560
|
-
const message = response.message || response.Message || errorCode;
|
|
3561
|
-
response.message = message;
|
|
3562
|
-
delete response.Message;
|
|
3563
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3564
2788
|
};
|
|
3565
2789
|
const deserializeAws_json1_1DescribeWorkingStorageCommand = async (output, context) => {
|
|
3566
2790
|
if (output.statusCode >= 300) {
|
|
@@ -3587,35 +2811,19 @@ const deserializeAws_json1_1DescribeWorkingStorageCommandError = async (output,
|
|
|
3587
2811
|
switch (errorCode) {
|
|
3588
2812
|
case "InternalServerError":
|
|
3589
2813
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3590
|
-
|
|
3591
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3592
|
-
name: errorCode,
|
|
3593
|
-
$metadata: deserializeMetadata(output),
|
|
3594
|
-
};
|
|
3595
|
-
break;
|
|
2814
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3596
2815
|
case "InvalidGatewayRequestException":
|
|
3597
2816
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3598
|
-
|
|
3599
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3600
|
-
name: errorCode,
|
|
3601
|
-
$metadata: deserializeMetadata(output),
|
|
3602
|
-
};
|
|
3603
|
-
break;
|
|
2817
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3604
2818
|
default:
|
|
3605
2819
|
const parsedBody = parsedOutput.body;
|
|
3606
|
-
|
|
3607
|
-
|
|
3608
|
-
...parsedBody,
|
|
3609
|
-
name: `${errorCode}`,
|
|
3610
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2820
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2821
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3611
2822
|
$fault: "client",
|
|
3612
2823
|
$metadata: deserializeMetadata(output),
|
|
3613
|
-
};
|
|
2824
|
+
});
|
|
2825
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3614
2826
|
}
|
|
3615
|
-
const message = response.message || response.Message || errorCode;
|
|
3616
|
-
response.message = message;
|
|
3617
|
-
delete response.Message;
|
|
3618
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3619
2827
|
};
|
|
3620
2828
|
const deserializeAws_json1_1DetachVolumeCommand = async (output, context) => {
|
|
3621
2829
|
if (output.statusCode >= 300) {
|
|
@@ -3642,35 +2850,19 @@ const deserializeAws_json1_1DetachVolumeCommandError = async (output, context) =
|
|
|
3642
2850
|
switch (errorCode) {
|
|
3643
2851
|
case "InternalServerError":
|
|
3644
2852
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3645
|
-
|
|
3646
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3647
|
-
name: errorCode,
|
|
3648
|
-
$metadata: deserializeMetadata(output),
|
|
3649
|
-
};
|
|
3650
|
-
break;
|
|
2853
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3651
2854
|
case "InvalidGatewayRequestException":
|
|
3652
2855
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3653
|
-
|
|
3654
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3655
|
-
name: errorCode,
|
|
3656
|
-
$metadata: deserializeMetadata(output),
|
|
3657
|
-
};
|
|
3658
|
-
break;
|
|
2856
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3659
2857
|
default:
|
|
3660
2858
|
const parsedBody = parsedOutput.body;
|
|
3661
|
-
|
|
3662
|
-
|
|
3663
|
-
...parsedBody,
|
|
3664
|
-
name: `${errorCode}`,
|
|
3665
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2859
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2860
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3666
2861
|
$fault: "client",
|
|
3667
2862
|
$metadata: deserializeMetadata(output),
|
|
3668
|
-
};
|
|
2863
|
+
});
|
|
2864
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3669
2865
|
}
|
|
3670
|
-
const message = response.message || response.Message || errorCode;
|
|
3671
|
-
response.message = message;
|
|
3672
|
-
delete response.Message;
|
|
3673
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3674
2866
|
};
|
|
3675
2867
|
const deserializeAws_json1_1DisableGatewayCommand = async (output, context) => {
|
|
3676
2868
|
if (output.statusCode >= 300) {
|
|
@@ -3697,35 +2889,19 @@ const deserializeAws_json1_1DisableGatewayCommandError = async (output, context)
|
|
|
3697
2889
|
switch (errorCode) {
|
|
3698
2890
|
case "InternalServerError":
|
|
3699
2891
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3700
|
-
|
|
3701
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3702
|
-
name: errorCode,
|
|
3703
|
-
$metadata: deserializeMetadata(output),
|
|
3704
|
-
};
|
|
3705
|
-
break;
|
|
2892
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3706
2893
|
case "InvalidGatewayRequestException":
|
|
3707
2894
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3708
|
-
|
|
3709
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3710
|
-
name: errorCode,
|
|
3711
|
-
$metadata: deserializeMetadata(output),
|
|
3712
|
-
};
|
|
3713
|
-
break;
|
|
2895
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3714
2896
|
default:
|
|
3715
2897
|
const parsedBody = parsedOutput.body;
|
|
3716
|
-
|
|
3717
|
-
|
|
3718
|
-
...parsedBody,
|
|
3719
|
-
name: `${errorCode}`,
|
|
3720
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2898
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2899
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3721
2900
|
$fault: "client",
|
|
3722
2901
|
$metadata: deserializeMetadata(output),
|
|
3723
|
-
};
|
|
2902
|
+
});
|
|
2903
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3724
2904
|
}
|
|
3725
|
-
const message = response.message || response.Message || errorCode;
|
|
3726
|
-
response.message = message;
|
|
3727
|
-
delete response.Message;
|
|
3728
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3729
2905
|
};
|
|
3730
2906
|
const deserializeAws_json1_1DisassociateFileSystemCommand = async (output, context) => {
|
|
3731
2907
|
if (output.statusCode >= 300) {
|
|
@@ -3752,35 +2928,19 @@ const deserializeAws_json1_1DisassociateFileSystemCommandError = async (output,
|
|
|
3752
2928
|
switch (errorCode) {
|
|
3753
2929
|
case "InternalServerError":
|
|
3754
2930
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3755
|
-
|
|
3756
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3757
|
-
name: errorCode,
|
|
3758
|
-
$metadata: deserializeMetadata(output),
|
|
3759
|
-
};
|
|
3760
|
-
break;
|
|
2931
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3761
2932
|
case "InvalidGatewayRequestException":
|
|
3762
2933
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3763
|
-
|
|
3764
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3765
|
-
name: errorCode,
|
|
3766
|
-
$metadata: deserializeMetadata(output),
|
|
3767
|
-
};
|
|
3768
|
-
break;
|
|
2934
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3769
2935
|
default:
|
|
3770
2936
|
const parsedBody = parsedOutput.body;
|
|
3771
|
-
|
|
3772
|
-
|
|
3773
|
-
...parsedBody,
|
|
3774
|
-
name: `${errorCode}`,
|
|
3775
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2937
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2938
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3776
2939
|
$fault: "client",
|
|
3777
2940
|
$metadata: deserializeMetadata(output),
|
|
3778
|
-
};
|
|
2941
|
+
});
|
|
2942
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3779
2943
|
}
|
|
3780
|
-
const message = response.message || response.Message || errorCode;
|
|
3781
|
-
response.message = message;
|
|
3782
|
-
delete response.Message;
|
|
3783
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3784
2944
|
};
|
|
3785
2945
|
const deserializeAws_json1_1JoinDomainCommand = async (output, context) => {
|
|
3786
2946
|
if (output.statusCode >= 300) {
|
|
@@ -3807,35 +2967,19 @@ const deserializeAws_json1_1JoinDomainCommandError = async (output, context) =>
|
|
|
3807
2967
|
switch (errorCode) {
|
|
3808
2968
|
case "InternalServerError":
|
|
3809
2969
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3810
|
-
|
|
3811
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3812
|
-
name: errorCode,
|
|
3813
|
-
$metadata: deserializeMetadata(output),
|
|
3814
|
-
};
|
|
3815
|
-
break;
|
|
2970
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3816
2971
|
case "InvalidGatewayRequestException":
|
|
3817
2972
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3818
|
-
|
|
3819
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3820
|
-
name: errorCode,
|
|
3821
|
-
$metadata: deserializeMetadata(output),
|
|
3822
|
-
};
|
|
3823
|
-
break;
|
|
2973
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3824
2974
|
default:
|
|
3825
2975
|
const parsedBody = parsedOutput.body;
|
|
3826
|
-
|
|
3827
|
-
|
|
3828
|
-
...parsedBody,
|
|
3829
|
-
name: `${errorCode}`,
|
|
3830
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
2976
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
2977
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3831
2978
|
$fault: "client",
|
|
3832
2979
|
$metadata: deserializeMetadata(output),
|
|
3833
|
-
};
|
|
2980
|
+
});
|
|
2981
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3834
2982
|
}
|
|
3835
|
-
const message = response.message || response.Message || errorCode;
|
|
3836
|
-
response.message = message;
|
|
3837
|
-
delete response.Message;
|
|
3838
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3839
2983
|
};
|
|
3840
2984
|
const deserializeAws_json1_1ListAutomaticTapeCreationPoliciesCommand = async (output, context) => {
|
|
3841
2985
|
if (output.statusCode >= 300) {
|
|
@@ -3862,35 +3006,19 @@ const deserializeAws_json1_1ListAutomaticTapeCreationPoliciesCommandError = asyn
|
|
|
3862
3006
|
switch (errorCode) {
|
|
3863
3007
|
case "InternalServerError":
|
|
3864
3008
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3865
|
-
|
|
3866
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3867
|
-
name: errorCode,
|
|
3868
|
-
$metadata: deserializeMetadata(output),
|
|
3869
|
-
};
|
|
3870
|
-
break;
|
|
3009
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3871
3010
|
case "InvalidGatewayRequestException":
|
|
3872
3011
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3873
|
-
|
|
3874
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3875
|
-
name: errorCode,
|
|
3876
|
-
$metadata: deserializeMetadata(output),
|
|
3877
|
-
};
|
|
3878
|
-
break;
|
|
3012
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3879
3013
|
default:
|
|
3880
3014
|
const parsedBody = parsedOutput.body;
|
|
3881
|
-
|
|
3882
|
-
|
|
3883
|
-
...parsedBody,
|
|
3884
|
-
name: `${errorCode}`,
|
|
3885
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3015
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3016
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3886
3017
|
$fault: "client",
|
|
3887
3018
|
$metadata: deserializeMetadata(output),
|
|
3888
|
-
};
|
|
3019
|
+
});
|
|
3020
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3889
3021
|
}
|
|
3890
|
-
const message = response.message || response.Message || errorCode;
|
|
3891
|
-
response.message = message;
|
|
3892
|
-
delete response.Message;
|
|
3893
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3894
3022
|
};
|
|
3895
3023
|
const deserializeAws_json1_1ListFileSharesCommand = async (output, context) => {
|
|
3896
3024
|
if (output.statusCode >= 300) {
|
|
@@ -3917,35 +3045,19 @@ const deserializeAws_json1_1ListFileSharesCommandError = async (output, context)
|
|
|
3917
3045
|
switch (errorCode) {
|
|
3918
3046
|
case "InternalServerError":
|
|
3919
3047
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3920
|
-
|
|
3921
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3922
|
-
name: errorCode,
|
|
3923
|
-
$metadata: deserializeMetadata(output),
|
|
3924
|
-
};
|
|
3925
|
-
break;
|
|
3048
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3926
3049
|
case "InvalidGatewayRequestException":
|
|
3927
3050
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3928
|
-
|
|
3929
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3930
|
-
name: errorCode,
|
|
3931
|
-
$metadata: deserializeMetadata(output),
|
|
3932
|
-
};
|
|
3933
|
-
break;
|
|
3051
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3934
3052
|
default:
|
|
3935
3053
|
const parsedBody = parsedOutput.body;
|
|
3936
|
-
|
|
3937
|
-
|
|
3938
|
-
...parsedBody,
|
|
3939
|
-
name: `${errorCode}`,
|
|
3940
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3054
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3055
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3941
3056
|
$fault: "client",
|
|
3942
3057
|
$metadata: deserializeMetadata(output),
|
|
3943
|
-
};
|
|
3058
|
+
});
|
|
3059
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3944
3060
|
}
|
|
3945
|
-
const message = response.message || response.Message || errorCode;
|
|
3946
|
-
response.message = message;
|
|
3947
|
-
delete response.Message;
|
|
3948
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3949
3061
|
};
|
|
3950
3062
|
const deserializeAws_json1_1ListFileSystemAssociationsCommand = async (output, context) => {
|
|
3951
3063
|
if (output.statusCode >= 300) {
|
|
@@ -3972,35 +3084,19 @@ const deserializeAws_json1_1ListFileSystemAssociationsCommandError = async (outp
|
|
|
3972
3084
|
switch (errorCode) {
|
|
3973
3085
|
case "InternalServerError":
|
|
3974
3086
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
3975
|
-
|
|
3976
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
3977
|
-
name: errorCode,
|
|
3978
|
-
$metadata: deserializeMetadata(output),
|
|
3979
|
-
};
|
|
3980
|
-
break;
|
|
3087
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
3981
3088
|
case "InvalidGatewayRequestException":
|
|
3982
3089
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
3983
|
-
|
|
3984
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
3985
|
-
name: errorCode,
|
|
3986
|
-
$metadata: deserializeMetadata(output),
|
|
3987
|
-
};
|
|
3988
|
-
break;
|
|
3090
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
3989
3091
|
default:
|
|
3990
3092
|
const parsedBody = parsedOutput.body;
|
|
3991
|
-
|
|
3992
|
-
|
|
3993
|
-
...parsedBody,
|
|
3994
|
-
name: `${errorCode}`,
|
|
3995
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3093
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3094
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
3996
3095
|
$fault: "client",
|
|
3997
3096
|
$metadata: deserializeMetadata(output),
|
|
3998
|
-
};
|
|
3097
|
+
});
|
|
3098
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
3999
3099
|
}
|
|
4000
|
-
const message = response.message || response.Message || errorCode;
|
|
4001
|
-
response.message = message;
|
|
4002
|
-
delete response.Message;
|
|
4003
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4004
3100
|
};
|
|
4005
3101
|
const deserializeAws_json1_1ListGatewaysCommand = async (output, context) => {
|
|
4006
3102
|
if (output.statusCode >= 300) {
|
|
@@ -4027,35 +3123,19 @@ const deserializeAws_json1_1ListGatewaysCommandError = async (output, context) =
|
|
|
4027
3123
|
switch (errorCode) {
|
|
4028
3124
|
case "InternalServerError":
|
|
4029
3125
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4030
|
-
|
|
4031
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4032
|
-
name: errorCode,
|
|
4033
|
-
$metadata: deserializeMetadata(output),
|
|
4034
|
-
};
|
|
4035
|
-
break;
|
|
3126
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4036
3127
|
case "InvalidGatewayRequestException":
|
|
4037
3128
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4038
|
-
|
|
4039
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4040
|
-
name: errorCode,
|
|
4041
|
-
$metadata: deserializeMetadata(output),
|
|
4042
|
-
};
|
|
4043
|
-
break;
|
|
3129
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4044
3130
|
default:
|
|
4045
3131
|
const parsedBody = parsedOutput.body;
|
|
4046
|
-
|
|
4047
|
-
|
|
4048
|
-
...parsedBody,
|
|
4049
|
-
name: `${errorCode}`,
|
|
4050
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3132
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3133
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4051
3134
|
$fault: "client",
|
|
4052
3135
|
$metadata: deserializeMetadata(output),
|
|
4053
|
-
};
|
|
3136
|
+
});
|
|
3137
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4054
3138
|
}
|
|
4055
|
-
const message = response.message || response.Message || errorCode;
|
|
4056
|
-
response.message = message;
|
|
4057
|
-
delete response.Message;
|
|
4058
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4059
3139
|
};
|
|
4060
3140
|
const deserializeAws_json1_1ListLocalDisksCommand = async (output, context) => {
|
|
4061
3141
|
if (output.statusCode >= 300) {
|
|
@@ -4082,35 +3162,19 @@ const deserializeAws_json1_1ListLocalDisksCommandError = async (output, context)
|
|
|
4082
3162
|
switch (errorCode) {
|
|
4083
3163
|
case "InternalServerError":
|
|
4084
3164
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4085
|
-
|
|
4086
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4087
|
-
name: errorCode,
|
|
4088
|
-
$metadata: deserializeMetadata(output),
|
|
4089
|
-
};
|
|
4090
|
-
break;
|
|
3165
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4091
3166
|
case "InvalidGatewayRequestException":
|
|
4092
3167
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4093
|
-
|
|
4094
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4095
|
-
name: errorCode,
|
|
4096
|
-
$metadata: deserializeMetadata(output),
|
|
4097
|
-
};
|
|
4098
|
-
break;
|
|
3168
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4099
3169
|
default:
|
|
4100
3170
|
const parsedBody = parsedOutput.body;
|
|
4101
|
-
|
|
4102
|
-
|
|
4103
|
-
...parsedBody,
|
|
4104
|
-
name: `${errorCode}`,
|
|
4105
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3171
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3172
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4106
3173
|
$fault: "client",
|
|
4107
3174
|
$metadata: deserializeMetadata(output),
|
|
4108
|
-
};
|
|
3175
|
+
});
|
|
3176
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4109
3177
|
}
|
|
4110
|
-
const message = response.message || response.Message || errorCode;
|
|
4111
|
-
response.message = message;
|
|
4112
|
-
delete response.Message;
|
|
4113
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4114
3178
|
};
|
|
4115
3179
|
const deserializeAws_json1_1ListTagsForResourceCommand = async (output, context) => {
|
|
4116
3180
|
if (output.statusCode >= 300) {
|
|
@@ -4137,35 +3201,19 @@ const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, con
|
|
|
4137
3201
|
switch (errorCode) {
|
|
4138
3202
|
case "InternalServerError":
|
|
4139
3203
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4140
|
-
|
|
4141
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4142
|
-
name: errorCode,
|
|
4143
|
-
$metadata: deserializeMetadata(output),
|
|
4144
|
-
};
|
|
4145
|
-
break;
|
|
3204
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4146
3205
|
case "InvalidGatewayRequestException":
|
|
4147
3206
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4148
|
-
|
|
4149
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4150
|
-
name: errorCode,
|
|
4151
|
-
$metadata: deserializeMetadata(output),
|
|
4152
|
-
};
|
|
4153
|
-
break;
|
|
3207
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4154
3208
|
default:
|
|
4155
3209
|
const parsedBody = parsedOutput.body;
|
|
4156
|
-
|
|
4157
|
-
|
|
4158
|
-
...parsedBody,
|
|
4159
|
-
name: `${errorCode}`,
|
|
4160
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3210
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3211
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4161
3212
|
$fault: "client",
|
|
4162
3213
|
$metadata: deserializeMetadata(output),
|
|
4163
|
-
};
|
|
3214
|
+
});
|
|
3215
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4164
3216
|
}
|
|
4165
|
-
const message = response.message || response.Message || errorCode;
|
|
4166
|
-
response.message = message;
|
|
4167
|
-
delete response.Message;
|
|
4168
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4169
3217
|
};
|
|
4170
3218
|
const deserializeAws_json1_1ListTapePoolsCommand = async (output, context) => {
|
|
4171
3219
|
if (output.statusCode >= 300) {
|
|
@@ -4192,35 +3240,19 @@ const deserializeAws_json1_1ListTapePoolsCommandError = async (output, context)
|
|
|
4192
3240
|
switch (errorCode) {
|
|
4193
3241
|
case "InternalServerError":
|
|
4194
3242
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4195
|
-
|
|
4196
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4197
|
-
name: errorCode,
|
|
4198
|
-
$metadata: deserializeMetadata(output),
|
|
4199
|
-
};
|
|
4200
|
-
break;
|
|
3243
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4201
3244
|
case "InvalidGatewayRequestException":
|
|
4202
3245
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4203
|
-
|
|
4204
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4205
|
-
name: errorCode,
|
|
4206
|
-
$metadata: deserializeMetadata(output),
|
|
4207
|
-
};
|
|
4208
|
-
break;
|
|
3246
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4209
3247
|
default:
|
|
4210
3248
|
const parsedBody = parsedOutput.body;
|
|
4211
|
-
|
|
4212
|
-
|
|
4213
|
-
...parsedBody,
|
|
4214
|
-
name: `${errorCode}`,
|
|
4215
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3249
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3250
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4216
3251
|
$fault: "client",
|
|
4217
3252
|
$metadata: deserializeMetadata(output),
|
|
4218
|
-
};
|
|
3253
|
+
});
|
|
3254
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4219
3255
|
}
|
|
4220
|
-
const message = response.message || response.Message || errorCode;
|
|
4221
|
-
response.message = message;
|
|
4222
|
-
delete response.Message;
|
|
4223
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4224
3256
|
};
|
|
4225
3257
|
const deserializeAws_json1_1ListTapesCommand = async (output, context) => {
|
|
4226
3258
|
if (output.statusCode >= 300) {
|
|
@@ -4247,35 +3279,19 @@ const deserializeAws_json1_1ListTapesCommandError = async (output, context) => {
|
|
|
4247
3279
|
switch (errorCode) {
|
|
4248
3280
|
case "InternalServerError":
|
|
4249
3281
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4250
|
-
|
|
4251
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4252
|
-
name: errorCode,
|
|
4253
|
-
$metadata: deserializeMetadata(output),
|
|
4254
|
-
};
|
|
4255
|
-
break;
|
|
3282
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4256
3283
|
case "InvalidGatewayRequestException":
|
|
4257
3284
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4258
|
-
|
|
4259
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4260
|
-
name: errorCode,
|
|
4261
|
-
$metadata: deserializeMetadata(output),
|
|
4262
|
-
};
|
|
4263
|
-
break;
|
|
3285
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4264
3286
|
default:
|
|
4265
3287
|
const parsedBody = parsedOutput.body;
|
|
4266
|
-
|
|
4267
|
-
|
|
4268
|
-
...parsedBody,
|
|
4269
|
-
name: `${errorCode}`,
|
|
4270
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3288
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3289
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4271
3290
|
$fault: "client",
|
|
4272
3291
|
$metadata: deserializeMetadata(output),
|
|
4273
|
-
};
|
|
3292
|
+
});
|
|
3293
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4274
3294
|
}
|
|
4275
|
-
const message = response.message || response.Message || errorCode;
|
|
4276
|
-
response.message = message;
|
|
4277
|
-
delete response.Message;
|
|
4278
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4279
3295
|
};
|
|
4280
3296
|
const deserializeAws_json1_1ListVolumeInitiatorsCommand = async (output, context) => {
|
|
4281
3297
|
if (output.statusCode >= 300) {
|
|
@@ -4302,35 +3318,19 @@ const deserializeAws_json1_1ListVolumeInitiatorsCommandError = async (output, co
|
|
|
4302
3318
|
switch (errorCode) {
|
|
4303
3319
|
case "InternalServerError":
|
|
4304
3320
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4305
|
-
|
|
4306
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4307
|
-
name: errorCode,
|
|
4308
|
-
$metadata: deserializeMetadata(output),
|
|
4309
|
-
};
|
|
4310
|
-
break;
|
|
3321
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4311
3322
|
case "InvalidGatewayRequestException":
|
|
4312
3323
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4313
|
-
|
|
4314
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4315
|
-
name: errorCode,
|
|
4316
|
-
$metadata: deserializeMetadata(output),
|
|
4317
|
-
};
|
|
4318
|
-
break;
|
|
3324
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4319
3325
|
default:
|
|
4320
3326
|
const parsedBody = parsedOutput.body;
|
|
4321
|
-
|
|
4322
|
-
|
|
4323
|
-
...parsedBody,
|
|
4324
|
-
name: `${errorCode}`,
|
|
4325
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3327
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3328
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4326
3329
|
$fault: "client",
|
|
4327
3330
|
$metadata: deserializeMetadata(output),
|
|
4328
|
-
};
|
|
3331
|
+
});
|
|
3332
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4329
3333
|
}
|
|
4330
|
-
const message = response.message || response.Message || errorCode;
|
|
4331
|
-
response.message = message;
|
|
4332
|
-
delete response.Message;
|
|
4333
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4334
3334
|
};
|
|
4335
3335
|
const deserializeAws_json1_1ListVolumeRecoveryPointsCommand = async (output, context) => {
|
|
4336
3336
|
if (output.statusCode >= 300) {
|
|
@@ -4357,35 +3357,19 @@ const deserializeAws_json1_1ListVolumeRecoveryPointsCommandError = async (output
|
|
|
4357
3357
|
switch (errorCode) {
|
|
4358
3358
|
case "InternalServerError":
|
|
4359
3359
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4360
|
-
|
|
4361
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4362
|
-
name: errorCode,
|
|
4363
|
-
$metadata: deserializeMetadata(output),
|
|
4364
|
-
};
|
|
4365
|
-
break;
|
|
3360
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4366
3361
|
case "InvalidGatewayRequestException":
|
|
4367
3362
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4368
|
-
|
|
4369
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4370
|
-
name: errorCode,
|
|
4371
|
-
$metadata: deserializeMetadata(output),
|
|
4372
|
-
};
|
|
4373
|
-
break;
|
|
3363
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4374
3364
|
default:
|
|
4375
3365
|
const parsedBody = parsedOutput.body;
|
|
4376
|
-
|
|
4377
|
-
|
|
4378
|
-
...parsedBody,
|
|
4379
|
-
name: `${errorCode}`,
|
|
4380
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3366
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3367
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4381
3368
|
$fault: "client",
|
|
4382
3369
|
$metadata: deserializeMetadata(output),
|
|
4383
|
-
};
|
|
3370
|
+
});
|
|
3371
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4384
3372
|
}
|
|
4385
|
-
const message = response.message || response.Message || errorCode;
|
|
4386
|
-
response.message = message;
|
|
4387
|
-
delete response.Message;
|
|
4388
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4389
3373
|
};
|
|
4390
3374
|
const deserializeAws_json1_1ListVolumesCommand = async (output, context) => {
|
|
4391
3375
|
if (output.statusCode >= 300) {
|
|
@@ -4412,35 +3396,19 @@ const deserializeAws_json1_1ListVolumesCommandError = async (output, context) =>
|
|
|
4412
3396
|
switch (errorCode) {
|
|
4413
3397
|
case "InternalServerError":
|
|
4414
3398
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4415
|
-
|
|
4416
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4417
|
-
name: errorCode,
|
|
4418
|
-
$metadata: deserializeMetadata(output),
|
|
4419
|
-
};
|
|
4420
|
-
break;
|
|
3399
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4421
3400
|
case "InvalidGatewayRequestException":
|
|
4422
3401
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4423
|
-
|
|
4424
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4425
|
-
name: errorCode,
|
|
4426
|
-
$metadata: deserializeMetadata(output),
|
|
4427
|
-
};
|
|
4428
|
-
break;
|
|
3402
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4429
3403
|
default:
|
|
4430
3404
|
const parsedBody = parsedOutput.body;
|
|
4431
|
-
|
|
4432
|
-
|
|
4433
|
-
...parsedBody,
|
|
4434
|
-
name: `${errorCode}`,
|
|
4435
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3405
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3406
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4436
3407
|
$fault: "client",
|
|
4437
3408
|
$metadata: deserializeMetadata(output),
|
|
4438
|
-
};
|
|
3409
|
+
});
|
|
3410
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4439
3411
|
}
|
|
4440
|
-
const message = response.message || response.Message || errorCode;
|
|
4441
|
-
response.message = message;
|
|
4442
|
-
delete response.Message;
|
|
4443
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4444
3412
|
};
|
|
4445
3413
|
const deserializeAws_json1_1NotifyWhenUploadedCommand = async (output, context) => {
|
|
4446
3414
|
if (output.statusCode >= 300) {
|
|
@@ -4467,35 +3435,19 @@ const deserializeAws_json1_1NotifyWhenUploadedCommandError = async (output, cont
|
|
|
4467
3435
|
switch (errorCode) {
|
|
4468
3436
|
case "InternalServerError":
|
|
4469
3437
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4470
|
-
|
|
4471
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4472
|
-
name: errorCode,
|
|
4473
|
-
$metadata: deserializeMetadata(output),
|
|
4474
|
-
};
|
|
4475
|
-
break;
|
|
3438
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4476
3439
|
case "InvalidGatewayRequestException":
|
|
4477
3440
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4478
|
-
|
|
4479
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4480
|
-
name: errorCode,
|
|
4481
|
-
$metadata: deserializeMetadata(output),
|
|
4482
|
-
};
|
|
4483
|
-
break;
|
|
3441
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4484
3442
|
default:
|
|
4485
3443
|
const parsedBody = parsedOutput.body;
|
|
4486
|
-
|
|
4487
|
-
|
|
4488
|
-
...parsedBody,
|
|
4489
|
-
name: `${errorCode}`,
|
|
4490
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3444
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3445
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4491
3446
|
$fault: "client",
|
|
4492
3447
|
$metadata: deserializeMetadata(output),
|
|
4493
|
-
};
|
|
3448
|
+
});
|
|
3449
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4494
3450
|
}
|
|
4495
|
-
const message = response.message || response.Message || errorCode;
|
|
4496
|
-
response.message = message;
|
|
4497
|
-
delete response.Message;
|
|
4498
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4499
3451
|
};
|
|
4500
3452
|
const deserializeAws_json1_1RefreshCacheCommand = async (output, context) => {
|
|
4501
3453
|
if (output.statusCode >= 300) {
|
|
@@ -4522,35 +3474,19 @@ const deserializeAws_json1_1RefreshCacheCommandError = async (output, context) =
|
|
|
4522
3474
|
switch (errorCode) {
|
|
4523
3475
|
case "InternalServerError":
|
|
4524
3476
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4525
|
-
|
|
4526
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4527
|
-
name: errorCode,
|
|
4528
|
-
$metadata: deserializeMetadata(output),
|
|
4529
|
-
};
|
|
4530
|
-
break;
|
|
3477
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4531
3478
|
case "InvalidGatewayRequestException":
|
|
4532
3479
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4533
|
-
|
|
4534
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4535
|
-
name: errorCode,
|
|
4536
|
-
$metadata: deserializeMetadata(output),
|
|
4537
|
-
};
|
|
4538
|
-
break;
|
|
3480
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4539
3481
|
default:
|
|
4540
3482
|
const parsedBody = parsedOutput.body;
|
|
4541
|
-
|
|
4542
|
-
|
|
4543
|
-
...parsedBody,
|
|
4544
|
-
name: `${errorCode}`,
|
|
4545
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3483
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3484
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4546
3485
|
$fault: "client",
|
|
4547
3486
|
$metadata: deserializeMetadata(output),
|
|
4548
|
-
};
|
|
3487
|
+
});
|
|
3488
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4549
3489
|
}
|
|
4550
|
-
const message = response.message || response.Message || errorCode;
|
|
4551
|
-
response.message = message;
|
|
4552
|
-
delete response.Message;
|
|
4553
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4554
3490
|
};
|
|
4555
3491
|
const deserializeAws_json1_1RemoveTagsFromResourceCommand = async (output, context) => {
|
|
4556
3492
|
if (output.statusCode >= 300) {
|
|
@@ -4577,35 +3513,19 @@ const deserializeAws_json1_1RemoveTagsFromResourceCommandError = async (output,
|
|
|
4577
3513
|
switch (errorCode) {
|
|
4578
3514
|
case "InternalServerError":
|
|
4579
3515
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4580
|
-
|
|
4581
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4582
|
-
name: errorCode,
|
|
4583
|
-
$metadata: deserializeMetadata(output),
|
|
4584
|
-
};
|
|
4585
|
-
break;
|
|
3516
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4586
3517
|
case "InvalidGatewayRequestException":
|
|
4587
3518
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4588
|
-
|
|
4589
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4590
|
-
name: errorCode,
|
|
4591
|
-
$metadata: deserializeMetadata(output),
|
|
4592
|
-
};
|
|
4593
|
-
break;
|
|
3519
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4594
3520
|
default:
|
|
4595
3521
|
const parsedBody = parsedOutput.body;
|
|
4596
|
-
|
|
4597
|
-
|
|
4598
|
-
...parsedBody,
|
|
4599
|
-
name: `${errorCode}`,
|
|
4600
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3522
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3523
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4601
3524
|
$fault: "client",
|
|
4602
3525
|
$metadata: deserializeMetadata(output),
|
|
4603
|
-
};
|
|
3526
|
+
});
|
|
3527
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4604
3528
|
}
|
|
4605
|
-
const message = response.message || response.Message || errorCode;
|
|
4606
|
-
response.message = message;
|
|
4607
|
-
delete response.Message;
|
|
4608
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4609
3529
|
};
|
|
4610
3530
|
const deserializeAws_json1_1ResetCacheCommand = async (output, context) => {
|
|
4611
3531
|
if (output.statusCode >= 300) {
|
|
@@ -4632,35 +3552,19 @@ const deserializeAws_json1_1ResetCacheCommandError = async (output, context) =>
|
|
|
4632
3552
|
switch (errorCode) {
|
|
4633
3553
|
case "InternalServerError":
|
|
4634
3554
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4635
|
-
|
|
4636
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4637
|
-
name: errorCode,
|
|
4638
|
-
$metadata: deserializeMetadata(output),
|
|
4639
|
-
};
|
|
4640
|
-
break;
|
|
3555
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4641
3556
|
case "InvalidGatewayRequestException":
|
|
4642
3557
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4643
|
-
|
|
4644
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4645
|
-
name: errorCode,
|
|
4646
|
-
$metadata: deserializeMetadata(output),
|
|
4647
|
-
};
|
|
4648
|
-
break;
|
|
3558
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4649
3559
|
default:
|
|
4650
3560
|
const parsedBody = parsedOutput.body;
|
|
4651
|
-
|
|
4652
|
-
|
|
4653
|
-
...parsedBody,
|
|
4654
|
-
name: `${errorCode}`,
|
|
4655
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3561
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3562
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4656
3563
|
$fault: "client",
|
|
4657
3564
|
$metadata: deserializeMetadata(output),
|
|
4658
|
-
};
|
|
3565
|
+
});
|
|
3566
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4659
3567
|
}
|
|
4660
|
-
const message = response.message || response.Message || errorCode;
|
|
4661
|
-
response.message = message;
|
|
4662
|
-
delete response.Message;
|
|
4663
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4664
3568
|
};
|
|
4665
3569
|
const deserializeAws_json1_1RetrieveTapeArchiveCommand = async (output, context) => {
|
|
4666
3570
|
if (output.statusCode >= 300) {
|
|
@@ -4687,35 +3591,19 @@ const deserializeAws_json1_1RetrieveTapeArchiveCommandError = async (output, con
|
|
|
4687
3591
|
switch (errorCode) {
|
|
4688
3592
|
case "InternalServerError":
|
|
4689
3593
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4690
|
-
|
|
4691
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4692
|
-
name: errorCode,
|
|
4693
|
-
$metadata: deserializeMetadata(output),
|
|
4694
|
-
};
|
|
4695
|
-
break;
|
|
3594
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4696
3595
|
case "InvalidGatewayRequestException":
|
|
4697
3596
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4698
|
-
|
|
4699
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4700
|
-
name: errorCode,
|
|
4701
|
-
$metadata: deserializeMetadata(output),
|
|
4702
|
-
};
|
|
4703
|
-
break;
|
|
3597
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4704
3598
|
default:
|
|
4705
3599
|
const parsedBody = parsedOutput.body;
|
|
4706
|
-
|
|
4707
|
-
|
|
4708
|
-
...parsedBody,
|
|
4709
|
-
name: `${errorCode}`,
|
|
4710
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3600
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3601
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4711
3602
|
$fault: "client",
|
|
4712
3603
|
$metadata: deserializeMetadata(output),
|
|
4713
|
-
};
|
|
3604
|
+
});
|
|
3605
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4714
3606
|
}
|
|
4715
|
-
const message = response.message || response.Message || errorCode;
|
|
4716
|
-
response.message = message;
|
|
4717
|
-
delete response.Message;
|
|
4718
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4719
3607
|
};
|
|
4720
3608
|
const deserializeAws_json1_1RetrieveTapeRecoveryPointCommand = async (output, context) => {
|
|
4721
3609
|
if (output.statusCode >= 300) {
|
|
@@ -4742,35 +3630,19 @@ const deserializeAws_json1_1RetrieveTapeRecoveryPointCommandError = async (outpu
|
|
|
4742
3630
|
switch (errorCode) {
|
|
4743
3631
|
case "InternalServerError":
|
|
4744
3632
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4745
|
-
|
|
4746
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4747
|
-
name: errorCode,
|
|
4748
|
-
$metadata: deserializeMetadata(output),
|
|
4749
|
-
};
|
|
4750
|
-
break;
|
|
3633
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4751
3634
|
case "InvalidGatewayRequestException":
|
|
4752
3635
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4753
|
-
|
|
4754
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4755
|
-
name: errorCode,
|
|
4756
|
-
$metadata: deserializeMetadata(output),
|
|
4757
|
-
};
|
|
4758
|
-
break;
|
|
3636
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4759
3637
|
default:
|
|
4760
3638
|
const parsedBody = parsedOutput.body;
|
|
4761
|
-
|
|
4762
|
-
|
|
4763
|
-
...parsedBody,
|
|
4764
|
-
name: `${errorCode}`,
|
|
4765
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3639
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3640
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4766
3641
|
$fault: "client",
|
|
4767
3642
|
$metadata: deserializeMetadata(output),
|
|
4768
|
-
};
|
|
3643
|
+
});
|
|
3644
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4769
3645
|
}
|
|
4770
|
-
const message = response.message || response.Message || errorCode;
|
|
4771
|
-
response.message = message;
|
|
4772
|
-
delete response.Message;
|
|
4773
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4774
3646
|
};
|
|
4775
3647
|
const deserializeAws_json1_1SetLocalConsolePasswordCommand = async (output, context) => {
|
|
4776
3648
|
if (output.statusCode >= 300) {
|
|
@@ -4797,35 +3669,19 @@ const deserializeAws_json1_1SetLocalConsolePasswordCommandError = async (output,
|
|
|
4797
3669
|
switch (errorCode) {
|
|
4798
3670
|
case "InternalServerError":
|
|
4799
3671
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4800
|
-
|
|
4801
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4802
|
-
name: errorCode,
|
|
4803
|
-
$metadata: deserializeMetadata(output),
|
|
4804
|
-
};
|
|
4805
|
-
break;
|
|
3672
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4806
3673
|
case "InvalidGatewayRequestException":
|
|
4807
3674
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4808
|
-
|
|
4809
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4810
|
-
name: errorCode,
|
|
4811
|
-
$metadata: deserializeMetadata(output),
|
|
4812
|
-
};
|
|
4813
|
-
break;
|
|
3675
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4814
3676
|
default:
|
|
4815
3677
|
const parsedBody = parsedOutput.body;
|
|
4816
|
-
|
|
4817
|
-
|
|
4818
|
-
...parsedBody,
|
|
4819
|
-
name: `${errorCode}`,
|
|
4820
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3678
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3679
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4821
3680
|
$fault: "client",
|
|
4822
3681
|
$metadata: deserializeMetadata(output),
|
|
4823
|
-
};
|
|
3682
|
+
});
|
|
3683
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4824
3684
|
}
|
|
4825
|
-
const message = response.message || response.Message || errorCode;
|
|
4826
|
-
response.message = message;
|
|
4827
|
-
delete response.Message;
|
|
4828
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4829
3685
|
};
|
|
4830
3686
|
const deserializeAws_json1_1SetSMBGuestPasswordCommand = async (output, context) => {
|
|
4831
3687
|
if (output.statusCode >= 300) {
|
|
@@ -4852,35 +3708,19 @@ const deserializeAws_json1_1SetSMBGuestPasswordCommandError = async (output, con
|
|
|
4852
3708
|
switch (errorCode) {
|
|
4853
3709
|
case "InternalServerError":
|
|
4854
3710
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4855
|
-
|
|
4856
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4857
|
-
name: errorCode,
|
|
4858
|
-
$metadata: deserializeMetadata(output),
|
|
4859
|
-
};
|
|
4860
|
-
break;
|
|
3711
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4861
3712
|
case "InvalidGatewayRequestException":
|
|
4862
3713
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4863
|
-
|
|
4864
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4865
|
-
name: errorCode,
|
|
4866
|
-
$metadata: deserializeMetadata(output),
|
|
4867
|
-
};
|
|
4868
|
-
break;
|
|
3714
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4869
3715
|
default:
|
|
4870
3716
|
const parsedBody = parsedOutput.body;
|
|
4871
|
-
|
|
4872
|
-
|
|
4873
|
-
...parsedBody,
|
|
4874
|
-
name: `${errorCode}`,
|
|
4875
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3717
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3718
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4876
3719
|
$fault: "client",
|
|
4877
3720
|
$metadata: deserializeMetadata(output),
|
|
4878
|
-
};
|
|
3721
|
+
});
|
|
3722
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4879
3723
|
}
|
|
4880
|
-
const message = response.message || response.Message || errorCode;
|
|
4881
|
-
response.message = message;
|
|
4882
|
-
delete response.Message;
|
|
4883
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4884
3724
|
};
|
|
4885
3725
|
const deserializeAws_json1_1ShutdownGatewayCommand = async (output, context) => {
|
|
4886
3726
|
if (output.statusCode >= 300) {
|
|
@@ -4907,35 +3747,19 @@ const deserializeAws_json1_1ShutdownGatewayCommandError = async (output, context
|
|
|
4907
3747
|
switch (errorCode) {
|
|
4908
3748
|
case "InternalServerError":
|
|
4909
3749
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4910
|
-
|
|
4911
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4912
|
-
name: errorCode,
|
|
4913
|
-
$metadata: deserializeMetadata(output),
|
|
4914
|
-
};
|
|
4915
|
-
break;
|
|
3750
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4916
3751
|
case "InvalidGatewayRequestException":
|
|
4917
3752
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4918
|
-
|
|
4919
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4920
|
-
name: errorCode,
|
|
4921
|
-
$metadata: deserializeMetadata(output),
|
|
4922
|
-
};
|
|
4923
|
-
break;
|
|
3753
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4924
3754
|
default:
|
|
4925
3755
|
const parsedBody = parsedOutput.body;
|
|
4926
|
-
|
|
4927
|
-
|
|
4928
|
-
...parsedBody,
|
|
4929
|
-
name: `${errorCode}`,
|
|
4930
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3756
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3757
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4931
3758
|
$fault: "client",
|
|
4932
3759
|
$metadata: deserializeMetadata(output),
|
|
4933
|
-
};
|
|
3760
|
+
});
|
|
3761
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4934
3762
|
}
|
|
4935
|
-
const message = response.message || response.Message || errorCode;
|
|
4936
|
-
response.message = message;
|
|
4937
|
-
delete response.Message;
|
|
4938
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4939
3763
|
};
|
|
4940
3764
|
const deserializeAws_json1_1StartAvailabilityMonitorTestCommand = async (output, context) => {
|
|
4941
3765
|
if (output.statusCode >= 300) {
|
|
@@ -4962,35 +3786,19 @@ const deserializeAws_json1_1StartAvailabilityMonitorTestCommandError = async (ou
|
|
|
4962
3786
|
switch (errorCode) {
|
|
4963
3787
|
case "InternalServerError":
|
|
4964
3788
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
4965
|
-
|
|
4966
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
4967
|
-
name: errorCode,
|
|
4968
|
-
$metadata: deserializeMetadata(output),
|
|
4969
|
-
};
|
|
4970
|
-
break;
|
|
3789
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
4971
3790
|
case "InvalidGatewayRequestException":
|
|
4972
3791
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
4973
|
-
|
|
4974
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
4975
|
-
name: errorCode,
|
|
4976
|
-
$metadata: deserializeMetadata(output),
|
|
4977
|
-
};
|
|
4978
|
-
break;
|
|
3792
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
4979
3793
|
default:
|
|
4980
3794
|
const parsedBody = parsedOutput.body;
|
|
4981
|
-
|
|
4982
|
-
|
|
4983
|
-
...parsedBody,
|
|
4984
|
-
name: `${errorCode}`,
|
|
4985
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3795
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3796
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
4986
3797
|
$fault: "client",
|
|
4987
3798
|
$metadata: deserializeMetadata(output),
|
|
4988
|
-
};
|
|
3799
|
+
});
|
|
3800
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
4989
3801
|
}
|
|
4990
|
-
const message = response.message || response.Message || errorCode;
|
|
4991
|
-
response.message = message;
|
|
4992
|
-
delete response.Message;
|
|
4993
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4994
3802
|
};
|
|
4995
3803
|
const deserializeAws_json1_1StartGatewayCommand = async (output, context) => {
|
|
4996
3804
|
if (output.statusCode >= 300) {
|
|
@@ -5017,35 +3825,19 @@ const deserializeAws_json1_1StartGatewayCommandError = async (output, context) =
|
|
|
5017
3825
|
switch (errorCode) {
|
|
5018
3826
|
case "InternalServerError":
|
|
5019
3827
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5020
|
-
|
|
5021
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5022
|
-
name: errorCode,
|
|
5023
|
-
$metadata: deserializeMetadata(output),
|
|
5024
|
-
};
|
|
5025
|
-
break;
|
|
3828
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5026
3829
|
case "InvalidGatewayRequestException":
|
|
5027
3830
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5028
|
-
|
|
5029
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5030
|
-
name: errorCode,
|
|
5031
|
-
$metadata: deserializeMetadata(output),
|
|
5032
|
-
};
|
|
5033
|
-
break;
|
|
3831
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5034
3832
|
default:
|
|
5035
3833
|
const parsedBody = parsedOutput.body;
|
|
5036
|
-
|
|
5037
|
-
|
|
5038
|
-
...parsedBody,
|
|
5039
|
-
name: `${errorCode}`,
|
|
5040
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3834
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3835
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5041
3836
|
$fault: "client",
|
|
5042
3837
|
$metadata: deserializeMetadata(output),
|
|
5043
|
-
};
|
|
3838
|
+
});
|
|
3839
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5044
3840
|
}
|
|
5045
|
-
const message = response.message || response.Message || errorCode;
|
|
5046
|
-
response.message = message;
|
|
5047
|
-
delete response.Message;
|
|
5048
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5049
3841
|
};
|
|
5050
3842
|
const deserializeAws_json1_1UpdateAutomaticTapeCreationPolicyCommand = async (output, context) => {
|
|
5051
3843
|
if (output.statusCode >= 300) {
|
|
@@ -5072,35 +3864,19 @@ const deserializeAws_json1_1UpdateAutomaticTapeCreationPolicyCommandError = asyn
|
|
|
5072
3864
|
switch (errorCode) {
|
|
5073
3865
|
case "InternalServerError":
|
|
5074
3866
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5075
|
-
|
|
5076
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5077
|
-
name: errorCode,
|
|
5078
|
-
$metadata: deserializeMetadata(output),
|
|
5079
|
-
};
|
|
5080
|
-
break;
|
|
3867
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5081
3868
|
case "InvalidGatewayRequestException":
|
|
5082
3869
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5083
|
-
|
|
5084
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5085
|
-
name: errorCode,
|
|
5086
|
-
$metadata: deserializeMetadata(output),
|
|
5087
|
-
};
|
|
5088
|
-
break;
|
|
3870
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5089
3871
|
default:
|
|
5090
3872
|
const parsedBody = parsedOutput.body;
|
|
5091
|
-
|
|
5092
|
-
|
|
5093
|
-
...parsedBody,
|
|
5094
|
-
name: `${errorCode}`,
|
|
5095
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3873
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3874
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5096
3875
|
$fault: "client",
|
|
5097
3876
|
$metadata: deserializeMetadata(output),
|
|
5098
|
-
};
|
|
3877
|
+
});
|
|
3878
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5099
3879
|
}
|
|
5100
|
-
const message = response.message || response.Message || errorCode;
|
|
5101
|
-
response.message = message;
|
|
5102
|
-
delete response.Message;
|
|
5103
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5104
3880
|
};
|
|
5105
3881
|
const deserializeAws_json1_1UpdateBandwidthRateLimitCommand = async (output, context) => {
|
|
5106
3882
|
if (output.statusCode >= 300) {
|
|
@@ -5127,35 +3903,19 @@ const deserializeAws_json1_1UpdateBandwidthRateLimitCommandError = async (output
|
|
|
5127
3903
|
switch (errorCode) {
|
|
5128
3904
|
case "InternalServerError":
|
|
5129
3905
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5130
|
-
|
|
5131
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5132
|
-
name: errorCode,
|
|
5133
|
-
$metadata: deserializeMetadata(output),
|
|
5134
|
-
};
|
|
5135
|
-
break;
|
|
3906
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5136
3907
|
case "InvalidGatewayRequestException":
|
|
5137
3908
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5138
|
-
|
|
5139
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5140
|
-
name: errorCode,
|
|
5141
|
-
$metadata: deserializeMetadata(output),
|
|
5142
|
-
};
|
|
5143
|
-
break;
|
|
3909
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5144
3910
|
default:
|
|
5145
3911
|
const parsedBody = parsedOutput.body;
|
|
5146
|
-
|
|
5147
|
-
|
|
5148
|
-
...parsedBody,
|
|
5149
|
-
name: `${errorCode}`,
|
|
5150
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3912
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3913
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5151
3914
|
$fault: "client",
|
|
5152
3915
|
$metadata: deserializeMetadata(output),
|
|
5153
|
-
};
|
|
3916
|
+
});
|
|
3917
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5154
3918
|
}
|
|
5155
|
-
const message = response.message || response.Message || errorCode;
|
|
5156
|
-
response.message = message;
|
|
5157
|
-
delete response.Message;
|
|
5158
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5159
3919
|
};
|
|
5160
3920
|
const deserializeAws_json1_1UpdateBandwidthRateLimitScheduleCommand = async (output, context) => {
|
|
5161
3921
|
if (output.statusCode >= 300) {
|
|
@@ -5182,35 +3942,19 @@ const deserializeAws_json1_1UpdateBandwidthRateLimitScheduleCommandError = async
|
|
|
5182
3942
|
switch (errorCode) {
|
|
5183
3943
|
case "InternalServerError":
|
|
5184
3944
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5185
|
-
|
|
5186
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5187
|
-
name: errorCode,
|
|
5188
|
-
$metadata: deserializeMetadata(output),
|
|
5189
|
-
};
|
|
5190
|
-
break;
|
|
3945
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5191
3946
|
case "InvalidGatewayRequestException":
|
|
5192
3947
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5193
|
-
|
|
5194
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5195
|
-
name: errorCode,
|
|
5196
|
-
$metadata: deserializeMetadata(output),
|
|
5197
|
-
};
|
|
5198
|
-
break;
|
|
3948
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5199
3949
|
default:
|
|
5200
3950
|
const parsedBody = parsedOutput.body;
|
|
5201
|
-
|
|
5202
|
-
|
|
5203
|
-
...parsedBody,
|
|
5204
|
-
name: `${errorCode}`,
|
|
5205
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3951
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3952
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5206
3953
|
$fault: "client",
|
|
5207
3954
|
$metadata: deserializeMetadata(output),
|
|
5208
|
-
};
|
|
3955
|
+
});
|
|
3956
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5209
3957
|
}
|
|
5210
|
-
const message = response.message || response.Message || errorCode;
|
|
5211
|
-
response.message = message;
|
|
5212
|
-
delete response.Message;
|
|
5213
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5214
3958
|
};
|
|
5215
3959
|
const deserializeAws_json1_1UpdateChapCredentialsCommand = async (output, context) => {
|
|
5216
3960
|
if (output.statusCode >= 300) {
|
|
@@ -5237,35 +3981,19 @@ const deserializeAws_json1_1UpdateChapCredentialsCommandError = async (output, c
|
|
|
5237
3981
|
switch (errorCode) {
|
|
5238
3982
|
case "InternalServerError":
|
|
5239
3983
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5240
|
-
|
|
5241
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5242
|
-
name: errorCode,
|
|
5243
|
-
$metadata: deserializeMetadata(output),
|
|
5244
|
-
};
|
|
5245
|
-
break;
|
|
3984
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5246
3985
|
case "InvalidGatewayRequestException":
|
|
5247
3986
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5248
|
-
|
|
5249
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5250
|
-
name: errorCode,
|
|
5251
|
-
$metadata: deserializeMetadata(output),
|
|
5252
|
-
};
|
|
5253
|
-
break;
|
|
3987
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5254
3988
|
default:
|
|
5255
3989
|
const parsedBody = parsedOutput.body;
|
|
5256
|
-
|
|
5257
|
-
|
|
5258
|
-
...parsedBody,
|
|
5259
|
-
name: `${errorCode}`,
|
|
5260
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
3990
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
3991
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5261
3992
|
$fault: "client",
|
|
5262
3993
|
$metadata: deserializeMetadata(output),
|
|
5263
|
-
};
|
|
3994
|
+
});
|
|
3995
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5264
3996
|
}
|
|
5265
|
-
const message = response.message || response.Message || errorCode;
|
|
5266
|
-
response.message = message;
|
|
5267
|
-
delete response.Message;
|
|
5268
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5269
3997
|
};
|
|
5270
3998
|
const deserializeAws_json1_1UpdateFileSystemAssociationCommand = async (output, context) => {
|
|
5271
3999
|
if (output.statusCode >= 300) {
|
|
@@ -5292,35 +4020,19 @@ const deserializeAws_json1_1UpdateFileSystemAssociationCommandError = async (out
|
|
|
5292
4020
|
switch (errorCode) {
|
|
5293
4021
|
case "InternalServerError":
|
|
5294
4022
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5295
|
-
|
|
5296
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5297
|
-
name: errorCode,
|
|
5298
|
-
$metadata: deserializeMetadata(output),
|
|
5299
|
-
};
|
|
5300
|
-
break;
|
|
4023
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5301
4024
|
case "InvalidGatewayRequestException":
|
|
5302
4025
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5303
|
-
|
|
5304
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5305
|
-
name: errorCode,
|
|
5306
|
-
$metadata: deserializeMetadata(output),
|
|
5307
|
-
};
|
|
5308
|
-
break;
|
|
4026
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5309
4027
|
default:
|
|
5310
4028
|
const parsedBody = parsedOutput.body;
|
|
5311
|
-
|
|
5312
|
-
|
|
5313
|
-
...parsedBody,
|
|
5314
|
-
name: `${errorCode}`,
|
|
5315
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4029
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
4030
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5316
4031
|
$fault: "client",
|
|
5317
4032
|
$metadata: deserializeMetadata(output),
|
|
5318
|
-
};
|
|
4033
|
+
});
|
|
4034
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5319
4035
|
}
|
|
5320
|
-
const message = response.message || response.Message || errorCode;
|
|
5321
|
-
response.message = message;
|
|
5322
|
-
delete response.Message;
|
|
5323
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5324
4036
|
};
|
|
5325
4037
|
const deserializeAws_json1_1UpdateGatewayInformationCommand = async (output, context) => {
|
|
5326
4038
|
if (output.statusCode >= 300) {
|
|
@@ -5347,35 +4059,19 @@ const deserializeAws_json1_1UpdateGatewayInformationCommandError = async (output
|
|
|
5347
4059
|
switch (errorCode) {
|
|
5348
4060
|
case "InternalServerError":
|
|
5349
4061
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5350
|
-
|
|
5351
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5352
|
-
name: errorCode,
|
|
5353
|
-
$metadata: deserializeMetadata(output),
|
|
5354
|
-
};
|
|
5355
|
-
break;
|
|
4062
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5356
4063
|
case "InvalidGatewayRequestException":
|
|
5357
4064
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5358
|
-
|
|
5359
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5360
|
-
name: errorCode,
|
|
5361
|
-
$metadata: deserializeMetadata(output),
|
|
5362
|
-
};
|
|
5363
|
-
break;
|
|
4065
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5364
4066
|
default:
|
|
5365
4067
|
const parsedBody = parsedOutput.body;
|
|
5366
|
-
|
|
5367
|
-
|
|
5368
|
-
...parsedBody,
|
|
5369
|
-
name: `${errorCode}`,
|
|
5370
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4068
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
4069
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5371
4070
|
$fault: "client",
|
|
5372
4071
|
$metadata: deserializeMetadata(output),
|
|
5373
|
-
};
|
|
4072
|
+
});
|
|
4073
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5374
4074
|
}
|
|
5375
|
-
const message = response.message || response.Message || errorCode;
|
|
5376
|
-
response.message = message;
|
|
5377
|
-
delete response.Message;
|
|
5378
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5379
4075
|
};
|
|
5380
4076
|
const deserializeAws_json1_1UpdateGatewaySoftwareNowCommand = async (output, context) => {
|
|
5381
4077
|
if (output.statusCode >= 300) {
|
|
@@ -5402,35 +4098,19 @@ const deserializeAws_json1_1UpdateGatewaySoftwareNowCommandError = async (output
|
|
|
5402
4098
|
switch (errorCode) {
|
|
5403
4099
|
case "InternalServerError":
|
|
5404
4100
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5405
|
-
|
|
5406
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5407
|
-
name: errorCode,
|
|
5408
|
-
$metadata: deserializeMetadata(output),
|
|
5409
|
-
};
|
|
5410
|
-
break;
|
|
4101
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5411
4102
|
case "InvalidGatewayRequestException":
|
|
5412
4103
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5413
|
-
|
|
5414
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5415
|
-
name: errorCode,
|
|
5416
|
-
$metadata: deserializeMetadata(output),
|
|
5417
|
-
};
|
|
5418
|
-
break;
|
|
4104
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5419
4105
|
default:
|
|
5420
4106
|
const parsedBody = parsedOutput.body;
|
|
5421
|
-
|
|
5422
|
-
|
|
5423
|
-
...parsedBody,
|
|
5424
|
-
name: `${errorCode}`,
|
|
5425
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4107
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
4108
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5426
4109
|
$fault: "client",
|
|
5427
4110
|
$metadata: deserializeMetadata(output),
|
|
5428
|
-
};
|
|
4111
|
+
});
|
|
4112
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5429
4113
|
}
|
|
5430
|
-
const message = response.message || response.Message || errorCode;
|
|
5431
|
-
response.message = message;
|
|
5432
|
-
delete response.Message;
|
|
5433
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5434
4114
|
};
|
|
5435
4115
|
const deserializeAws_json1_1UpdateMaintenanceStartTimeCommand = async (output, context) => {
|
|
5436
4116
|
if (output.statusCode >= 300) {
|
|
@@ -5457,35 +4137,19 @@ const deserializeAws_json1_1UpdateMaintenanceStartTimeCommandError = async (outp
|
|
|
5457
4137
|
switch (errorCode) {
|
|
5458
4138
|
case "InternalServerError":
|
|
5459
4139
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5460
|
-
|
|
5461
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5462
|
-
name: errorCode,
|
|
5463
|
-
$metadata: deserializeMetadata(output),
|
|
5464
|
-
};
|
|
5465
|
-
break;
|
|
4140
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5466
4141
|
case "InvalidGatewayRequestException":
|
|
5467
4142
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5468
|
-
|
|
5469
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5470
|
-
name: errorCode,
|
|
5471
|
-
$metadata: deserializeMetadata(output),
|
|
5472
|
-
};
|
|
5473
|
-
break;
|
|
4143
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5474
4144
|
default:
|
|
5475
4145
|
const parsedBody = parsedOutput.body;
|
|
5476
|
-
|
|
5477
|
-
|
|
5478
|
-
...parsedBody,
|
|
5479
|
-
name: `${errorCode}`,
|
|
5480
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4146
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
4147
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5481
4148
|
$fault: "client",
|
|
5482
4149
|
$metadata: deserializeMetadata(output),
|
|
5483
|
-
};
|
|
4150
|
+
});
|
|
4151
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5484
4152
|
}
|
|
5485
|
-
const message = response.message || response.Message || errorCode;
|
|
5486
|
-
response.message = message;
|
|
5487
|
-
delete response.Message;
|
|
5488
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5489
4153
|
};
|
|
5490
4154
|
const deserializeAws_json1_1UpdateNFSFileShareCommand = async (output, context) => {
|
|
5491
4155
|
if (output.statusCode >= 300) {
|
|
@@ -5512,35 +4176,19 @@ const deserializeAws_json1_1UpdateNFSFileShareCommandError = async (output, cont
|
|
|
5512
4176
|
switch (errorCode) {
|
|
5513
4177
|
case "InternalServerError":
|
|
5514
4178
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5515
|
-
|
|
5516
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5517
|
-
name: errorCode,
|
|
5518
|
-
$metadata: deserializeMetadata(output),
|
|
5519
|
-
};
|
|
5520
|
-
break;
|
|
4179
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5521
4180
|
case "InvalidGatewayRequestException":
|
|
5522
4181
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5523
|
-
|
|
5524
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5525
|
-
name: errorCode,
|
|
5526
|
-
$metadata: deserializeMetadata(output),
|
|
5527
|
-
};
|
|
5528
|
-
break;
|
|
4182
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5529
4183
|
default:
|
|
5530
4184
|
const parsedBody = parsedOutput.body;
|
|
5531
|
-
|
|
5532
|
-
|
|
5533
|
-
...parsedBody,
|
|
5534
|
-
name: `${errorCode}`,
|
|
5535
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4185
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
4186
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5536
4187
|
$fault: "client",
|
|
5537
4188
|
$metadata: deserializeMetadata(output),
|
|
5538
|
-
};
|
|
4189
|
+
});
|
|
4190
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5539
4191
|
}
|
|
5540
|
-
const message = response.message || response.Message || errorCode;
|
|
5541
|
-
response.message = message;
|
|
5542
|
-
delete response.Message;
|
|
5543
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5544
4192
|
};
|
|
5545
4193
|
const deserializeAws_json1_1UpdateSMBFileShareCommand = async (output, context) => {
|
|
5546
4194
|
if (output.statusCode >= 300) {
|
|
@@ -5567,35 +4215,19 @@ const deserializeAws_json1_1UpdateSMBFileShareCommandError = async (output, cont
|
|
|
5567
4215
|
switch (errorCode) {
|
|
5568
4216
|
case "InternalServerError":
|
|
5569
4217
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5570
|
-
|
|
5571
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5572
|
-
name: errorCode,
|
|
5573
|
-
$metadata: deserializeMetadata(output),
|
|
5574
|
-
};
|
|
5575
|
-
break;
|
|
4218
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5576
4219
|
case "InvalidGatewayRequestException":
|
|
5577
4220
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5578
|
-
|
|
5579
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5580
|
-
name: errorCode,
|
|
5581
|
-
$metadata: deserializeMetadata(output),
|
|
5582
|
-
};
|
|
5583
|
-
break;
|
|
4221
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5584
4222
|
default:
|
|
5585
4223
|
const parsedBody = parsedOutput.body;
|
|
5586
|
-
|
|
5587
|
-
|
|
5588
|
-
...parsedBody,
|
|
5589
|
-
name: `${errorCode}`,
|
|
5590
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4224
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
4225
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5591
4226
|
$fault: "client",
|
|
5592
4227
|
$metadata: deserializeMetadata(output),
|
|
5593
|
-
};
|
|
4228
|
+
});
|
|
4229
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5594
4230
|
}
|
|
5595
|
-
const message = response.message || response.Message || errorCode;
|
|
5596
|
-
response.message = message;
|
|
5597
|
-
delete response.Message;
|
|
5598
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5599
4231
|
};
|
|
5600
4232
|
const deserializeAws_json1_1UpdateSMBFileShareVisibilityCommand = async (output, context) => {
|
|
5601
4233
|
if (output.statusCode >= 300) {
|
|
@@ -5622,35 +4254,19 @@ const deserializeAws_json1_1UpdateSMBFileShareVisibilityCommandError = async (ou
|
|
|
5622
4254
|
switch (errorCode) {
|
|
5623
4255
|
case "InternalServerError":
|
|
5624
4256
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5625
|
-
|
|
5626
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5627
|
-
name: errorCode,
|
|
5628
|
-
$metadata: deserializeMetadata(output),
|
|
5629
|
-
};
|
|
5630
|
-
break;
|
|
4257
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5631
4258
|
case "InvalidGatewayRequestException":
|
|
5632
4259
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5633
|
-
|
|
5634
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5635
|
-
name: errorCode,
|
|
5636
|
-
$metadata: deserializeMetadata(output),
|
|
5637
|
-
};
|
|
5638
|
-
break;
|
|
4260
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5639
4261
|
default:
|
|
5640
4262
|
const parsedBody = parsedOutput.body;
|
|
5641
|
-
|
|
5642
|
-
|
|
5643
|
-
...parsedBody,
|
|
5644
|
-
name: `${errorCode}`,
|
|
5645
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4263
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
4264
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5646
4265
|
$fault: "client",
|
|
5647
4266
|
$metadata: deserializeMetadata(output),
|
|
5648
|
-
};
|
|
4267
|
+
});
|
|
4268
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5649
4269
|
}
|
|
5650
|
-
const message = response.message || response.Message || errorCode;
|
|
5651
|
-
response.message = message;
|
|
5652
|
-
delete response.Message;
|
|
5653
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5654
4270
|
};
|
|
5655
4271
|
const deserializeAws_json1_1UpdateSMBLocalGroupsCommand = async (output, context) => {
|
|
5656
4272
|
if (output.statusCode >= 300) {
|
|
@@ -5677,35 +4293,19 @@ const deserializeAws_json1_1UpdateSMBLocalGroupsCommandError = async (output, co
|
|
|
5677
4293
|
switch (errorCode) {
|
|
5678
4294
|
case "InternalServerError":
|
|
5679
4295
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5680
|
-
|
|
5681
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5682
|
-
name: errorCode,
|
|
5683
|
-
$metadata: deserializeMetadata(output),
|
|
5684
|
-
};
|
|
5685
|
-
break;
|
|
4296
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5686
4297
|
case "InvalidGatewayRequestException":
|
|
5687
4298
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5688
|
-
|
|
5689
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5690
|
-
name: errorCode,
|
|
5691
|
-
$metadata: deserializeMetadata(output),
|
|
5692
|
-
};
|
|
5693
|
-
break;
|
|
4299
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5694
4300
|
default:
|
|
5695
4301
|
const parsedBody = parsedOutput.body;
|
|
5696
|
-
|
|
5697
|
-
|
|
5698
|
-
...parsedBody,
|
|
5699
|
-
name: `${errorCode}`,
|
|
5700
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4302
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
4303
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5701
4304
|
$fault: "client",
|
|
5702
4305
|
$metadata: deserializeMetadata(output),
|
|
5703
|
-
};
|
|
4306
|
+
});
|
|
4307
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5704
4308
|
}
|
|
5705
|
-
const message = response.message || response.Message || errorCode;
|
|
5706
|
-
response.message = message;
|
|
5707
|
-
delete response.Message;
|
|
5708
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5709
4309
|
};
|
|
5710
4310
|
const deserializeAws_json1_1UpdateSMBSecurityStrategyCommand = async (output, context) => {
|
|
5711
4311
|
if (output.statusCode >= 300) {
|
|
@@ -5732,35 +4332,19 @@ const deserializeAws_json1_1UpdateSMBSecurityStrategyCommandError = async (outpu
|
|
|
5732
4332
|
switch (errorCode) {
|
|
5733
4333
|
case "InternalServerError":
|
|
5734
4334
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5735
|
-
|
|
5736
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5737
|
-
name: errorCode,
|
|
5738
|
-
$metadata: deserializeMetadata(output),
|
|
5739
|
-
};
|
|
5740
|
-
break;
|
|
4335
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5741
4336
|
case "InvalidGatewayRequestException":
|
|
5742
4337
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5743
|
-
|
|
5744
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5745
|
-
name: errorCode,
|
|
5746
|
-
$metadata: deserializeMetadata(output),
|
|
5747
|
-
};
|
|
5748
|
-
break;
|
|
4338
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5749
4339
|
default:
|
|
5750
4340
|
const parsedBody = parsedOutput.body;
|
|
5751
|
-
|
|
5752
|
-
|
|
5753
|
-
...parsedBody,
|
|
5754
|
-
name: `${errorCode}`,
|
|
5755
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4341
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
4342
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5756
4343
|
$fault: "client",
|
|
5757
4344
|
$metadata: deserializeMetadata(output),
|
|
5758
|
-
};
|
|
4345
|
+
});
|
|
4346
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5759
4347
|
}
|
|
5760
|
-
const message = response.message || response.Message || errorCode;
|
|
5761
|
-
response.message = message;
|
|
5762
|
-
delete response.Message;
|
|
5763
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5764
4348
|
};
|
|
5765
4349
|
const deserializeAws_json1_1UpdateSnapshotScheduleCommand = async (output, context) => {
|
|
5766
4350
|
if (output.statusCode >= 300) {
|
|
@@ -5787,35 +4371,19 @@ const deserializeAws_json1_1UpdateSnapshotScheduleCommandError = async (output,
|
|
|
5787
4371
|
switch (errorCode) {
|
|
5788
4372
|
case "InternalServerError":
|
|
5789
4373
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5790
|
-
|
|
5791
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5792
|
-
name: errorCode,
|
|
5793
|
-
$metadata: deserializeMetadata(output),
|
|
5794
|
-
};
|
|
5795
|
-
break;
|
|
4374
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5796
4375
|
case "InvalidGatewayRequestException":
|
|
5797
4376
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5798
|
-
|
|
5799
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5800
|
-
name: errorCode,
|
|
5801
|
-
$metadata: deserializeMetadata(output),
|
|
5802
|
-
};
|
|
5803
|
-
break;
|
|
4377
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5804
4378
|
default:
|
|
5805
4379
|
const parsedBody = parsedOutput.body;
|
|
5806
|
-
|
|
5807
|
-
|
|
5808
|
-
...parsedBody,
|
|
5809
|
-
name: `${errorCode}`,
|
|
5810
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4380
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
4381
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5811
4382
|
$fault: "client",
|
|
5812
4383
|
$metadata: deserializeMetadata(output),
|
|
5813
|
-
};
|
|
4384
|
+
});
|
|
4385
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5814
4386
|
}
|
|
5815
|
-
const message = response.message || response.Message || errorCode;
|
|
5816
|
-
response.message = message;
|
|
5817
|
-
delete response.Message;
|
|
5818
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5819
4387
|
};
|
|
5820
4388
|
const deserializeAws_json1_1UpdateVTLDeviceTypeCommand = async (output, context) => {
|
|
5821
4389
|
if (output.statusCode >= 300) {
|
|
@@ -5842,68 +4410,46 @@ const deserializeAws_json1_1UpdateVTLDeviceTypeCommandError = async (output, con
|
|
|
5842
4410
|
switch (errorCode) {
|
|
5843
4411
|
case "InternalServerError":
|
|
5844
4412
|
case "com.amazonaws.storagegateway#InternalServerError":
|
|
5845
|
-
|
|
5846
|
-
...(await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context)),
|
|
5847
|
-
name: errorCode,
|
|
5848
|
-
$metadata: deserializeMetadata(output),
|
|
5849
|
-
};
|
|
5850
|
-
break;
|
|
4413
|
+
throw await deserializeAws_json1_1InternalServerErrorResponse(parsedOutput, context);
|
|
5851
4414
|
case "InvalidGatewayRequestException":
|
|
5852
4415
|
case "com.amazonaws.storagegateway#InvalidGatewayRequestException":
|
|
5853
|
-
|
|
5854
|
-
...(await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context)),
|
|
5855
|
-
name: errorCode,
|
|
5856
|
-
$metadata: deserializeMetadata(output),
|
|
5857
|
-
};
|
|
5858
|
-
break;
|
|
4416
|
+
throw await deserializeAws_json1_1InvalidGatewayRequestExceptionResponse(parsedOutput, context);
|
|
5859
4417
|
default:
|
|
5860
4418
|
const parsedBody = parsedOutput.body;
|
|
5861
|
-
|
|
5862
|
-
|
|
5863
|
-
...parsedBody,
|
|
5864
|
-
name: `${errorCode}`,
|
|
5865
|
-
message: parsedBody.message || parsedBody.Message || errorCode,
|
|
4419
|
+
response = new StorageGatewayServiceException_1.StorageGatewayServiceException({
|
|
4420
|
+
name: parsedBody.code || parsedBody.Code || errorCode,
|
|
5866
4421
|
$fault: "client",
|
|
5867
4422
|
$metadata: deserializeMetadata(output),
|
|
5868
|
-
};
|
|
4423
|
+
});
|
|
4424
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody);
|
|
5869
4425
|
}
|
|
5870
|
-
const message = response.message || response.Message || errorCode;
|
|
5871
|
-
response.message = message;
|
|
5872
|
-
delete response.Message;
|
|
5873
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
5874
4426
|
};
|
|
5875
4427
|
const deserializeAws_json1_1InternalServerErrorResponse = async (parsedOutput, context) => {
|
|
5876
4428
|
const body = parsedOutput.body;
|
|
5877
4429
|
const deserialized = deserializeAws_json1_1InternalServerError(body, context);
|
|
5878
|
-
const
|
|
5879
|
-
name: "InternalServerError",
|
|
5880
|
-
$fault: "server",
|
|
4430
|
+
const exception = new models_0_1.InternalServerError({
|
|
5881
4431
|
$metadata: deserializeMetadata(parsedOutput),
|
|
5882
4432
|
...deserialized,
|
|
5883
|
-
};
|
|
5884
|
-
return
|
|
4433
|
+
});
|
|
4434
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
5885
4435
|
};
|
|
5886
4436
|
const deserializeAws_json1_1InvalidGatewayRequestExceptionResponse = async (parsedOutput, context) => {
|
|
5887
4437
|
const body = parsedOutput.body;
|
|
5888
4438
|
const deserialized = deserializeAws_json1_1InvalidGatewayRequestException(body, context);
|
|
5889
|
-
const
|
|
5890
|
-
name: "InvalidGatewayRequestException",
|
|
5891
|
-
$fault: "client",
|
|
4439
|
+
const exception = new models_0_1.InvalidGatewayRequestException({
|
|
5892
4440
|
$metadata: deserializeMetadata(parsedOutput),
|
|
5893
4441
|
...deserialized,
|
|
5894
|
-
};
|
|
5895
|
-
return
|
|
4442
|
+
});
|
|
4443
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
5896
4444
|
};
|
|
5897
4445
|
const deserializeAws_json1_1ServiceUnavailableErrorResponse = async (parsedOutput, context) => {
|
|
5898
4446
|
const body = parsedOutput.body;
|
|
5899
4447
|
const deserialized = deserializeAws_json1_1ServiceUnavailableError(body, context);
|
|
5900
|
-
const
|
|
5901
|
-
name: "ServiceUnavailableError",
|
|
5902
|
-
$fault: "server",
|
|
4448
|
+
const exception = new models_0_1.ServiceUnavailableError({
|
|
5903
4449
|
$metadata: deserializeMetadata(parsedOutput),
|
|
5904
4450
|
...deserialized,
|
|
5905
|
-
};
|
|
5906
|
-
return
|
|
4451
|
+
});
|
|
4452
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
5907
4453
|
};
|
|
5908
4454
|
const serializeAws_json1_1ActivateGatewayInput = (input, context) => {
|
|
5909
4455
|
return {
|
|
@@ -6997,7 +5543,7 @@ const deserializeAws_json1_1AutomaticTapeCreationPolicyInfo = (output, context)
|
|
|
6997
5543
|
};
|
|
6998
5544
|
};
|
|
6999
5545
|
const deserializeAws_json1_1AutomaticTapeCreationPolicyInfos = (output, context) => {
|
|
7000
|
-
|
|
5546
|
+
const retVal = (output || [])
|
|
7001
5547
|
.filter((e) => e != null)
|
|
7002
5548
|
.map((entry) => {
|
|
7003
5549
|
if (entry === null) {
|
|
@@ -7005,6 +5551,7 @@ const deserializeAws_json1_1AutomaticTapeCreationPolicyInfos = (output, context)
|
|
|
7005
5551
|
}
|
|
7006
5552
|
return deserializeAws_json1_1AutomaticTapeCreationPolicyInfo(entry, context);
|
|
7007
5553
|
});
|
|
5554
|
+
return retVal;
|
|
7008
5555
|
};
|
|
7009
5556
|
const deserializeAws_json1_1AutomaticTapeCreationRule = (output, context) => {
|
|
7010
5557
|
return {
|
|
@@ -7016,7 +5563,7 @@ const deserializeAws_json1_1AutomaticTapeCreationRule = (output, context) => {
|
|
|
7016
5563
|
};
|
|
7017
5564
|
};
|
|
7018
5565
|
const deserializeAws_json1_1AutomaticTapeCreationRules = (output, context) => {
|
|
7019
|
-
|
|
5566
|
+
const retVal = (output || [])
|
|
7020
5567
|
.filter((e) => e != null)
|
|
7021
5568
|
.map((entry) => {
|
|
7022
5569
|
if (entry === null) {
|
|
@@ -7024,6 +5571,7 @@ const deserializeAws_json1_1AutomaticTapeCreationRules = (output, context) => {
|
|
|
7024
5571
|
}
|
|
7025
5572
|
return deserializeAws_json1_1AutomaticTapeCreationRule(entry, context);
|
|
7026
5573
|
});
|
|
5574
|
+
return retVal;
|
|
7027
5575
|
};
|
|
7028
5576
|
const deserializeAws_json1_1BandwidthRateLimitInterval = (output, context) => {
|
|
7029
5577
|
return {
|
|
@@ -7039,7 +5587,7 @@ const deserializeAws_json1_1BandwidthRateLimitInterval = (output, context) => {
|
|
|
7039
5587
|
};
|
|
7040
5588
|
};
|
|
7041
5589
|
const deserializeAws_json1_1BandwidthRateLimitIntervals = (output, context) => {
|
|
7042
|
-
|
|
5590
|
+
const retVal = (output || [])
|
|
7043
5591
|
.filter((e) => e != null)
|
|
7044
5592
|
.map((entry) => {
|
|
7045
5593
|
if (entry === null) {
|
|
@@ -7047,6 +5595,7 @@ const deserializeAws_json1_1BandwidthRateLimitIntervals = (output, context) => {
|
|
|
7047
5595
|
}
|
|
7048
5596
|
return deserializeAws_json1_1BandwidthRateLimitInterval(entry, context);
|
|
7049
5597
|
});
|
|
5598
|
+
return retVal;
|
|
7050
5599
|
};
|
|
7051
5600
|
const deserializeAws_json1_1CacheAttributes = (output, context) => {
|
|
7052
5601
|
return {
|
|
@@ -7075,7 +5624,7 @@ const deserializeAws_json1_1CachediSCSIVolume = (output, context) => {
|
|
|
7075
5624
|
};
|
|
7076
5625
|
};
|
|
7077
5626
|
const deserializeAws_json1_1CachediSCSIVolumes = (output, context) => {
|
|
7078
|
-
|
|
5627
|
+
const retVal = (output || [])
|
|
7079
5628
|
.filter((e) => e != null)
|
|
7080
5629
|
.map((entry) => {
|
|
7081
5630
|
if (entry === null) {
|
|
@@ -7083,6 +5632,7 @@ const deserializeAws_json1_1CachediSCSIVolumes = (output, context) => {
|
|
|
7083
5632
|
}
|
|
7084
5633
|
return deserializeAws_json1_1CachediSCSIVolume(entry, context);
|
|
7085
5634
|
});
|
|
5635
|
+
return retVal;
|
|
7086
5636
|
};
|
|
7087
5637
|
const deserializeAws_json1_1CancelArchivalOutput = (output, context) => {
|
|
7088
5638
|
return {
|
|
@@ -7095,7 +5645,7 @@ const deserializeAws_json1_1CancelRetrievalOutput = (output, context) => {
|
|
|
7095
5645
|
};
|
|
7096
5646
|
};
|
|
7097
5647
|
const deserializeAws_json1_1ChapCredentials = (output, context) => {
|
|
7098
|
-
|
|
5648
|
+
const retVal = (output || [])
|
|
7099
5649
|
.filter((e) => e != null)
|
|
7100
5650
|
.map((entry) => {
|
|
7101
5651
|
if (entry === null) {
|
|
@@ -7103,6 +5653,7 @@ const deserializeAws_json1_1ChapCredentials = (output, context) => {
|
|
|
7103
5653
|
}
|
|
7104
5654
|
return deserializeAws_json1_1ChapInfo(entry, context);
|
|
7105
5655
|
});
|
|
5656
|
+
return retVal;
|
|
7106
5657
|
};
|
|
7107
5658
|
const deserializeAws_json1_1ChapInfo = (output, context) => {
|
|
7108
5659
|
return {
|
|
@@ -7166,7 +5717,7 @@ const deserializeAws_json1_1CreateTapeWithBarcodeOutput = (output, context) => {
|
|
|
7166
5717
|
};
|
|
7167
5718
|
};
|
|
7168
5719
|
const deserializeAws_json1_1DaysOfWeek = (output, context) => {
|
|
7169
|
-
|
|
5720
|
+
const retVal = (output || [])
|
|
7170
5721
|
.filter((e) => e != null)
|
|
7171
5722
|
.map((entry) => {
|
|
7172
5723
|
if (entry === null) {
|
|
@@ -7174,6 +5725,7 @@ const deserializeAws_json1_1DaysOfWeek = (output, context) => {
|
|
|
7174
5725
|
}
|
|
7175
5726
|
return smithy_client_1.expectInt32(entry);
|
|
7176
5727
|
});
|
|
5728
|
+
return retVal;
|
|
7177
5729
|
};
|
|
7178
5730
|
const deserializeAws_json1_1DeleteAutomaticTapeCreationPolicyOutput = (output, context) => {
|
|
7179
5731
|
return {
|
|
@@ -7459,7 +6011,7 @@ const deserializeAws_json1_1Disk = (output, context) => {
|
|
|
7459
6011
|
};
|
|
7460
6012
|
};
|
|
7461
6013
|
const deserializeAws_json1_1DiskAttributeList = (output, context) => {
|
|
7462
|
-
|
|
6014
|
+
const retVal = (output || [])
|
|
7463
6015
|
.filter((e) => e != null)
|
|
7464
6016
|
.map((entry) => {
|
|
7465
6017
|
if (entry === null) {
|
|
@@ -7467,9 +6019,10 @@ const deserializeAws_json1_1DiskAttributeList = (output, context) => {
|
|
|
7467
6019
|
}
|
|
7468
6020
|
return smithy_client_1.expectString(entry);
|
|
7469
6021
|
});
|
|
6022
|
+
return retVal;
|
|
7470
6023
|
};
|
|
7471
6024
|
const deserializeAws_json1_1DiskIds = (output, context) => {
|
|
7472
|
-
|
|
6025
|
+
const retVal = (output || [])
|
|
7473
6026
|
.filter((e) => e != null)
|
|
7474
6027
|
.map((entry) => {
|
|
7475
6028
|
if (entry === null) {
|
|
@@ -7477,9 +6030,10 @@ const deserializeAws_json1_1DiskIds = (output, context) => {
|
|
|
7477
6030
|
}
|
|
7478
6031
|
return smithy_client_1.expectString(entry);
|
|
7479
6032
|
});
|
|
6033
|
+
return retVal;
|
|
7480
6034
|
};
|
|
7481
6035
|
const deserializeAws_json1_1Disks = (output, context) => {
|
|
7482
|
-
|
|
6036
|
+
const retVal = (output || [])
|
|
7483
6037
|
.filter((e) => e != null)
|
|
7484
6038
|
.map((entry) => {
|
|
7485
6039
|
if (entry === null) {
|
|
@@ -7487,6 +6041,7 @@ const deserializeAws_json1_1Disks = (output, context) => {
|
|
|
7487
6041
|
}
|
|
7488
6042
|
return deserializeAws_json1_1Disk(entry, context);
|
|
7489
6043
|
});
|
|
6044
|
+
return retVal;
|
|
7490
6045
|
};
|
|
7491
6046
|
const deserializeAws_json1_1EndpointNetworkConfiguration = (output, context) => {
|
|
7492
6047
|
return {
|
|
@@ -7507,7 +6062,7 @@ const deserializeAws_json1_1errorDetails = (output, context) => {
|
|
|
7507
6062
|
}, {});
|
|
7508
6063
|
};
|
|
7509
6064
|
const deserializeAws_json1_1FileShareClientList = (output, context) => {
|
|
7510
|
-
|
|
6065
|
+
const retVal = (output || [])
|
|
7511
6066
|
.filter((e) => e != null)
|
|
7512
6067
|
.map((entry) => {
|
|
7513
6068
|
if (entry === null) {
|
|
@@ -7515,6 +6070,7 @@ const deserializeAws_json1_1FileShareClientList = (output, context) => {
|
|
|
7515
6070
|
}
|
|
7516
6071
|
return smithy_client_1.expectString(entry);
|
|
7517
6072
|
});
|
|
6073
|
+
return retVal;
|
|
7518
6074
|
};
|
|
7519
6075
|
const deserializeAws_json1_1FileShareInfo = (output, context) => {
|
|
7520
6076
|
return {
|
|
@@ -7526,7 +6082,7 @@ const deserializeAws_json1_1FileShareInfo = (output, context) => {
|
|
|
7526
6082
|
};
|
|
7527
6083
|
};
|
|
7528
6084
|
const deserializeAws_json1_1FileShareInfoList = (output, context) => {
|
|
7529
|
-
|
|
6085
|
+
const retVal = (output || [])
|
|
7530
6086
|
.filter((e) => e != null)
|
|
7531
6087
|
.map((entry) => {
|
|
7532
6088
|
if (entry === null) {
|
|
@@ -7534,6 +6090,7 @@ const deserializeAws_json1_1FileShareInfoList = (output, context) => {
|
|
|
7534
6090
|
}
|
|
7535
6091
|
return deserializeAws_json1_1FileShareInfo(entry, context);
|
|
7536
6092
|
});
|
|
6093
|
+
return retVal;
|
|
7537
6094
|
};
|
|
7538
6095
|
const deserializeAws_json1_1FileSystemAssociationInfo = (output, context) => {
|
|
7539
6096
|
return {
|
|
@@ -7555,7 +6112,7 @@ const deserializeAws_json1_1FileSystemAssociationInfo = (output, context) => {
|
|
|
7555
6112
|
};
|
|
7556
6113
|
};
|
|
7557
6114
|
const deserializeAws_json1_1FileSystemAssociationInfoList = (output, context) => {
|
|
7558
|
-
|
|
6115
|
+
const retVal = (output || [])
|
|
7559
6116
|
.filter((e) => e != null)
|
|
7560
6117
|
.map((entry) => {
|
|
7561
6118
|
if (entry === null) {
|
|
@@ -7563,6 +6120,7 @@ const deserializeAws_json1_1FileSystemAssociationInfoList = (output, context) =>
|
|
|
7563
6120
|
}
|
|
7564
6121
|
return deserializeAws_json1_1FileSystemAssociationInfo(entry, context);
|
|
7565
6122
|
});
|
|
6123
|
+
return retVal;
|
|
7566
6124
|
};
|
|
7567
6125
|
const deserializeAws_json1_1FileSystemAssociationStatusDetail = (output, context) => {
|
|
7568
6126
|
return {
|
|
@@ -7570,7 +6128,7 @@ const deserializeAws_json1_1FileSystemAssociationStatusDetail = (output, context
|
|
|
7570
6128
|
};
|
|
7571
6129
|
};
|
|
7572
6130
|
const deserializeAws_json1_1FileSystemAssociationStatusDetails = (output, context) => {
|
|
7573
|
-
|
|
6131
|
+
const retVal = (output || [])
|
|
7574
6132
|
.filter((e) => e != null)
|
|
7575
6133
|
.map((entry) => {
|
|
7576
6134
|
if (entry === null) {
|
|
@@ -7578,6 +6136,7 @@ const deserializeAws_json1_1FileSystemAssociationStatusDetails = (output, contex
|
|
|
7578
6136
|
}
|
|
7579
6137
|
return deserializeAws_json1_1FileSystemAssociationStatusDetail(entry, context);
|
|
7580
6138
|
});
|
|
6139
|
+
return retVal;
|
|
7581
6140
|
};
|
|
7582
6141
|
const deserializeAws_json1_1FileSystemAssociationSummary = (output, context) => {
|
|
7583
6142
|
return {
|
|
@@ -7588,7 +6147,7 @@ const deserializeAws_json1_1FileSystemAssociationSummary = (output, context) =>
|
|
|
7588
6147
|
};
|
|
7589
6148
|
};
|
|
7590
6149
|
const deserializeAws_json1_1FileSystemAssociationSummaryList = (output, context) => {
|
|
7591
|
-
|
|
6150
|
+
const retVal = (output || [])
|
|
7592
6151
|
.filter((e) => e != null)
|
|
7593
6152
|
.map((entry) => {
|
|
7594
6153
|
if (entry === null) {
|
|
@@ -7596,6 +6155,7 @@ const deserializeAws_json1_1FileSystemAssociationSummaryList = (output, context)
|
|
|
7596
6155
|
}
|
|
7597
6156
|
return deserializeAws_json1_1FileSystemAssociationSummary(entry, context);
|
|
7598
6157
|
});
|
|
6158
|
+
return retVal;
|
|
7599
6159
|
};
|
|
7600
6160
|
const deserializeAws_json1_1GatewayInfo = (output, context) => {
|
|
7601
6161
|
return {
|
|
@@ -7611,7 +6171,7 @@ const deserializeAws_json1_1GatewayInfo = (output, context) => {
|
|
|
7611
6171
|
};
|
|
7612
6172
|
};
|
|
7613
6173
|
const deserializeAws_json1_1GatewayNetworkInterfaces = (output, context) => {
|
|
7614
|
-
|
|
6174
|
+
const retVal = (output || [])
|
|
7615
6175
|
.filter((e) => e != null)
|
|
7616
6176
|
.map((entry) => {
|
|
7617
6177
|
if (entry === null) {
|
|
@@ -7619,9 +6179,10 @@ const deserializeAws_json1_1GatewayNetworkInterfaces = (output, context) => {
|
|
|
7619
6179
|
}
|
|
7620
6180
|
return deserializeAws_json1_1NetworkInterface(entry, context);
|
|
7621
6181
|
});
|
|
6182
|
+
return retVal;
|
|
7622
6183
|
};
|
|
7623
6184
|
const deserializeAws_json1_1Gateways = (output, context) => {
|
|
7624
|
-
|
|
6185
|
+
const retVal = (output || [])
|
|
7625
6186
|
.filter((e) => e != null)
|
|
7626
6187
|
.map((entry) => {
|
|
7627
6188
|
if (entry === null) {
|
|
@@ -7629,9 +6190,10 @@ const deserializeAws_json1_1Gateways = (output, context) => {
|
|
|
7629
6190
|
}
|
|
7630
6191
|
return deserializeAws_json1_1GatewayInfo(entry, context);
|
|
7631
6192
|
});
|
|
6193
|
+
return retVal;
|
|
7632
6194
|
};
|
|
7633
6195
|
const deserializeAws_json1_1Initiators = (output, context) => {
|
|
7634
|
-
|
|
6196
|
+
const retVal = (output || [])
|
|
7635
6197
|
.filter((e) => e != null)
|
|
7636
6198
|
.map((entry) => {
|
|
7637
6199
|
if (entry === null) {
|
|
@@ -7639,6 +6201,7 @@ const deserializeAws_json1_1Initiators = (output, context) => {
|
|
|
7639
6201
|
}
|
|
7640
6202
|
return smithy_client_1.expectString(entry);
|
|
7641
6203
|
});
|
|
6204
|
+
return retVal;
|
|
7642
6205
|
};
|
|
7643
6206
|
const deserializeAws_json1_1InternalServerError = (output, context) => {
|
|
7644
6207
|
return {
|
|
@@ -7657,7 +6220,7 @@ const deserializeAws_json1_1InvalidGatewayRequestException = (output, context) =
|
|
|
7657
6220
|
};
|
|
7658
6221
|
};
|
|
7659
6222
|
const deserializeAws_json1_1IpAddressList = (output, context) => {
|
|
7660
|
-
|
|
6223
|
+
const retVal = (output || [])
|
|
7661
6224
|
.filter((e) => e != null)
|
|
7662
6225
|
.map((entry) => {
|
|
7663
6226
|
if (entry === null) {
|
|
@@ -7665,6 +6228,7 @@ const deserializeAws_json1_1IpAddressList = (output, context) => {
|
|
|
7665
6228
|
}
|
|
7666
6229
|
return smithy_client_1.expectString(entry);
|
|
7667
6230
|
});
|
|
6231
|
+
return retVal;
|
|
7668
6232
|
};
|
|
7669
6233
|
const deserializeAws_json1_1JoinDomainOutput = (output, context) => {
|
|
7670
6234
|
return {
|
|
@@ -7810,7 +6374,7 @@ const deserializeAws_json1_1NFSFileShareInfo = (output, context) => {
|
|
|
7810
6374
|
};
|
|
7811
6375
|
};
|
|
7812
6376
|
const deserializeAws_json1_1NFSFileShareInfoList = (output, context) => {
|
|
7813
|
-
|
|
6377
|
+
const retVal = (output || [])
|
|
7814
6378
|
.filter((e) => e != null)
|
|
7815
6379
|
.map((entry) => {
|
|
7816
6380
|
if (entry === null) {
|
|
@@ -7818,6 +6382,7 @@ const deserializeAws_json1_1NFSFileShareInfoList = (output, context) => {
|
|
|
7818
6382
|
}
|
|
7819
6383
|
return deserializeAws_json1_1NFSFileShareInfo(entry, context);
|
|
7820
6384
|
});
|
|
6385
|
+
return retVal;
|
|
7821
6386
|
};
|
|
7822
6387
|
const deserializeAws_json1_1NotifyWhenUploadedOutput = (output, context) => {
|
|
7823
6388
|
return {
|
|
@@ -7836,7 +6401,7 @@ const deserializeAws_json1_1PoolInfo = (output, context) => {
|
|
|
7836
6401
|
};
|
|
7837
6402
|
};
|
|
7838
6403
|
const deserializeAws_json1_1PoolInfos = (output, context) => {
|
|
7839
|
-
|
|
6404
|
+
const retVal = (output || [])
|
|
7840
6405
|
.filter((e) => e != null)
|
|
7841
6406
|
.map((entry) => {
|
|
7842
6407
|
if (entry === null) {
|
|
@@ -7844,6 +6409,7 @@ const deserializeAws_json1_1PoolInfos = (output, context) => {
|
|
|
7844
6409
|
}
|
|
7845
6410
|
return deserializeAws_json1_1PoolInfo(entry, context);
|
|
7846
6411
|
});
|
|
6412
|
+
return retVal;
|
|
7847
6413
|
};
|
|
7848
6414
|
const deserializeAws_json1_1RefreshCacheOutput = (output, context) => {
|
|
7849
6415
|
return {
|
|
@@ -7936,7 +6502,7 @@ const deserializeAws_json1_1SMBFileShareInfo = (output, context) => {
|
|
|
7936
6502
|
};
|
|
7937
6503
|
};
|
|
7938
6504
|
const deserializeAws_json1_1SMBFileShareInfoList = (output, context) => {
|
|
7939
|
-
|
|
6505
|
+
const retVal = (output || [])
|
|
7940
6506
|
.filter((e) => e != null)
|
|
7941
6507
|
.map((entry) => {
|
|
7942
6508
|
if (entry === null) {
|
|
@@ -7944,6 +6510,7 @@ const deserializeAws_json1_1SMBFileShareInfoList = (output, context) => {
|
|
|
7944
6510
|
}
|
|
7945
6511
|
return deserializeAws_json1_1SMBFileShareInfo(entry, context);
|
|
7946
6512
|
});
|
|
6513
|
+
return retVal;
|
|
7947
6514
|
};
|
|
7948
6515
|
const deserializeAws_json1_1SMBLocalGroups = (output, context) => {
|
|
7949
6516
|
return {
|
|
@@ -7994,7 +6561,7 @@ const deserializeAws_json1_1StorediSCSIVolume = (output, context) => {
|
|
|
7994
6561
|
};
|
|
7995
6562
|
};
|
|
7996
6563
|
const deserializeAws_json1_1StorediSCSIVolumes = (output, context) => {
|
|
7997
|
-
|
|
6564
|
+
const retVal = (output || [])
|
|
7998
6565
|
.filter((e) => e != null)
|
|
7999
6566
|
.map((entry) => {
|
|
8000
6567
|
if (entry === null) {
|
|
@@ -8002,9 +6569,10 @@ const deserializeAws_json1_1StorediSCSIVolumes = (output, context) => {
|
|
|
8002
6569
|
}
|
|
8003
6570
|
return deserializeAws_json1_1StorediSCSIVolume(entry, context);
|
|
8004
6571
|
});
|
|
6572
|
+
return retVal;
|
|
8005
6573
|
};
|
|
8006
6574
|
const deserializeAws_json1_1SupportedGatewayCapacities = (output, context) => {
|
|
8007
|
-
|
|
6575
|
+
const retVal = (output || [])
|
|
8008
6576
|
.filter((e) => e != null)
|
|
8009
6577
|
.map((entry) => {
|
|
8010
6578
|
if (entry === null) {
|
|
@@ -8012,6 +6580,7 @@ const deserializeAws_json1_1SupportedGatewayCapacities = (output, context) => {
|
|
|
8012
6580
|
}
|
|
8013
6581
|
return smithy_client_1.expectString(entry);
|
|
8014
6582
|
});
|
|
6583
|
+
return retVal;
|
|
8015
6584
|
};
|
|
8016
6585
|
const deserializeAws_json1_1Tag = (output, context) => {
|
|
8017
6586
|
return {
|
|
@@ -8020,7 +6589,7 @@ const deserializeAws_json1_1Tag = (output, context) => {
|
|
|
8020
6589
|
};
|
|
8021
6590
|
};
|
|
8022
6591
|
const deserializeAws_json1_1Tags = (output, context) => {
|
|
8023
|
-
|
|
6592
|
+
const retVal = (output || [])
|
|
8024
6593
|
.filter((e) => e != null)
|
|
8025
6594
|
.map((entry) => {
|
|
8026
6595
|
if (entry === null) {
|
|
@@ -8028,6 +6597,7 @@ const deserializeAws_json1_1Tags = (output, context) => {
|
|
|
8028
6597
|
}
|
|
8029
6598
|
return deserializeAws_json1_1Tag(entry, context);
|
|
8030
6599
|
});
|
|
6600
|
+
return retVal;
|
|
8031
6601
|
};
|
|
8032
6602
|
const deserializeAws_json1_1Tape = (output, context) => {
|
|
8033
6603
|
return {
|
|
@@ -8078,7 +6648,7 @@ const deserializeAws_json1_1TapeArchive = (output, context) => {
|
|
|
8078
6648
|
};
|
|
8079
6649
|
};
|
|
8080
6650
|
const deserializeAws_json1_1TapeArchives = (output, context) => {
|
|
8081
|
-
|
|
6651
|
+
const retVal = (output || [])
|
|
8082
6652
|
.filter((e) => e != null)
|
|
8083
6653
|
.map((entry) => {
|
|
8084
6654
|
if (entry === null) {
|
|
@@ -8086,9 +6656,10 @@ const deserializeAws_json1_1TapeArchives = (output, context) => {
|
|
|
8086
6656
|
}
|
|
8087
6657
|
return deserializeAws_json1_1TapeArchive(entry, context);
|
|
8088
6658
|
});
|
|
6659
|
+
return retVal;
|
|
8089
6660
|
};
|
|
8090
6661
|
const deserializeAws_json1_1TapeARNs = (output, context) => {
|
|
8091
|
-
|
|
6662
|
+
const retVal = (output || [])
|
|
8092
6663
|
.filter((e) => e != null)
|
|
8093
6664
|
.map((entry) => {
|
|
8094
6665
|
if (entry === null) {
|
|
@@ -8096,6 +6667,7 @@ const deserializeAws_json1_1TapeARNs = (output, context) => {
|
|
|
8096
6667
|
}
|
|
8097
6668
|
return smithy_client_1.expectString(entry);
|
|
8098
6669
|
});
|
|
6670
|
+
return retVal;
|
|
8099
6671
|
};
|
|
8100
6672
|
const deserializeAws_json1_1TapeInfo = (output, context) => {
|
|
8101
6673
|
return {
|
|
@@ -8114,7 +6686,7 @@ const deserializeAws_json1_1TapeInfo = (output, context) => {
|
|
|
8114
6686
|
};
|
|
8115
6687
|
};
|
|
8116
6688
|
const deserializeAws_json1_1TapeInfos = (output, context) => {
|
|
8117
|
-
|
|
6689
|
+
const retVal = (output || [])
|
|
8118
6690
|
.filter((e) => e != null)
|
|
8119
6691
|
.map((entry) => {
|
|
8120
6692
|
if (entry === null) {
|
|
@@ -8122,6 +6694,7 @@ const deserializeAws_json1_1TapeInfos = (output, context) => {
|
|
|
8122
6694
|
}
|
|
8123
6695
|
return deserializeAws_json1_1TapeInfo(entry, context);
|
|
8124
6696
|
});
|
|
6697
|
+
return retVal;
|
|
8125
6698
|
};
|
|
8126
6699
|
const deserializeAws_json1_1TapeRecoveryPointInfo = (output, context) => {
|
|
8127
6700
|
return {
|
|
@@ -8134,7 +6707,7 @@ const deserializeAws_json1_1TapeRecoveryPointInfo = (output, context) => {
|
|
|
8134
6707
|
};
|
|
8135
6708
|
};
|
|
8136
6709
|
const deserializeAws_json1_1TapeRecoveryPointInfos = (output, context) => {
|
|
8137
|
-
|
|
6710
|
+
const retVal = (output || [])
|
|
8138
6711
|
.filter((e) => e != null)
|
|
8139
6712
|
.map((entry) => {
|
|
8140
6713
|
if (entry === null) {
|
|
@@ -8142,9 +6715,10 @@ const deserializeAws_json1_1TapeRecoveryPointInfos = (output, context) => {
|
|
|
8142
6715
|
}
|
|
8143
6716
|
return deserializeAws_json1_1TapeRecoveryPointInfo(entry, context);
|
|
8144
6717
|
});
|
|
6718
|
+
return retVal;
|
|
8145
6719
|
};
|
|
8146
6720
|
const deserializeAws_json1_1Tapes = (output, context) => {
|
|
8147
|
-
|
|
6721
|
+
const retVal = (output || [])
|
|
8148
6722
|
.filter((e) => e != null)
|
|
8149
6723
|
.map((entry) => {
|
|
8150
6724
|
if (entry === null) {
|
|
@@ -8152,6 +6726,7 @@ const deserializeAws_json1_1Tapes = (output, context) => {
|
|
|
8152
6726
|
}
|
|
8153
6727
|
return deserializeAws_json1_1Tape(entry, context);
|
|
8154
6728
|
});
|
|
6729
|
+
return retVal;
|
|
8155
6730
|
};
|
|
8156
6731
|
const deserializeAws_json1_1UpdateAutomaticTapeCreationPolicyOutput = (output, context) => {
|
|
8157
6732
|
return {
|
|
@@ -8231,7 +6806,7 @@ const deserializeAws_json1_1UpdateVTLDeviceTypeOutput = (output, context) => {
|
|
|
8231
6806
|
};
|
|
8232
6807
|
};
|
|
8233
6808
|
const deserializeAws_json1_1UserList = (output, context) => {
|
|
8234
|
-
|
|
6809
|
+
const retVal = (output || [])
|
|
8235
6810
|
.filter((e) => e != null)
|
|
8236
6811
|
.map((entry) => {
|
|
8237
6812
|
if (entry === null) {
|
|
@@ -8239,6 +6814,7 @@ const deserializeAws_json1_1UserList = (output, context) => {
|
|
|
8239
6814
|
}
|
|
8240
6815
|
return smithy_client_1.expectString(entry);
|
|
8241
6816
|
});
|
|
6817
|
+
return retVal;
|
|
8242
6818
|
};
|
|
8243
6819
|
const deserializeAws_json1_1VolumeInfo = (output, context) => {
|
|
8244
6820
|
return {
|
|
@@ -8252,7 +6828,7 @@ const deserializeAws_json1_1VolumeInfo = (output, context) => {
|
|
|
8252
6828
|
};
|
|
8253
6829
|
};
|
|
8254
6830
|
const deserializeAws_json1_1VolumeInfos = (output, context) => {
|
|
8255
|
-
|
|
6831
|
+
const retVal = (output || [])
|
|
8256
6832
|
.filter((e) => e != null)
|
|
8257
6833
|
.map((entry) => {
|
|
8258
6834
|
if (entry === null) {
|
|
@@ -8260,6 +6836,7 @@ const deserializeAws_json1_1VolumeInfos = (output, context) => {
|
|
|
8260
6836
|
}
|
|
8261
6837
|
return deserializeAws_json1_1VolumeInfo(entry, context);
|
|
8262
6838
|
});
|
|
6839
|
+
return retVal;
|
|
8263
6840
|
};
|
|
8264
6841
|
const deserializeAws_json1_1VolumeiSCSIAttributes = (output, context) => {
|
|
8265
6842
|
return {
|
|
@@ -8279,7 +6856,7 @@ const deserializeAws_json1_1VolumeRecoveryPointInfo = (output, context) => {
|
|
|
8279
6856
|
};
|
|
8280
6857
|
};
|
|
8281
6858
|
const deserializeAws_json1_1VolumeRecoveryPointInfos = (output, context) => {
|
|
8282
|
-
|
|
6859
|
+
const retVal = (output || [])
|
|
8283
6860
|
.filter((e) => e != null)
|
|
8284
6861
|
.map((entry) => {
|
|
8285
6862
|
if (entry === null) {
|
|
@@ -8287,6 +6864,7 @@ const deserializeAws_json1_1VolumeRecoveryPointInfos = (output, context) => {
|
|
|
8287
6864
|
}
|
|
8288
6865
|
return deserializeAws_json1_1VolumeRecoveryPointInfo(entry, context);
|
|
8289
6866
|
});
|
|
6867
|
+
return retVal;
|
|
8290
6868
|
};
|
|
8291
6869
|
const deserializeAws_json1_1VTLDevice = (output, context) => {
|
|
8292
6870
|
return {
|
|
@@ -8300,7 +6878,7 @@ const deserializeAws_json1_1VTLDevice = (output, context) => {
|
|
|
8300
6878
|
};
|
|
8301
6879
|
};
|
|
8302
6880
|
const deserializeAws_json1_1VTLDevices = (output, context) => {
|
|
8303
|
-
|
|
6881
|
+
const retVal = (output || [])
|
|
8304
6882
|
.filter((e) => e != null)
|
|
8305
6883
|
.map((entry) => {
|
|
8306
6884
|
if (entry === null) {
|
|
@@ -8308,6 +6886,7 @@ const deserializeAws_json1_1VTLDevices = (output, context) => {
|
|
|
8308
6886
|
}
|
|
8309
6887
|
return deserializeAws_json1_1VTLDevice(entry, context);
|
|
8310
6888
|
});
|
|
6889
|
+
return retVal;
|
|
8311
6890
|
};
|
|
8312
6891
|
const deserializeMetadata = (output) => {
|
|
8313
6892
|
var _a;
|