@aws-sdk/client-cloudformation 3.52.0 → 3.54.1
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 +27 -0
- package/dist-cjs/index.js +3 -0
- package/dist-cjs/models/CloudFormationServiceException.js +11 -0
- package/dist-cjs/models/models_0.js +314 -5
- package/dist-cjs/protocols/Aws_query.js +431 -1364
- package/dist-es/index.js +1 -0
- package/dist-es/models/CloudFormationServiceException.js +12 -0
- package/dist-es/models/models_0.js +288 -1
- package/dist-es/protocols/Aws_query.js +975 -1438
- package/dist-types/CloudFormationClient.d.ts +2 -2
- package/dist-types/index.d.ts +1 -0
- package/dist-types/models/CloudFormationServiceException.d.ts +10 -0
- package/dist-types/models/models_0.d.ts +156 -67
- package/dist-types/runtimeConfig.browser.d.ts +1 -1
- package/dist-types/runtimeConfig.d.ts +1 -1
- package/dist-types/runtimeConfig.native.d.ts +1 -1
- package/dist-types/ts3.4/CloudFormationClient.d.ts +2 -2
- package/dist-types/ts3.4/index.d.ts +1 -0
- package/dist-types/ts3.4/models/CloudFormationServiceException.d.ts +6 -0
- package/dist-types/ts3.4/models/models_0.d.ts +112 -67
- package/dist-types/ts3.4/runtimeConfig.browser.d.ts +1 -1
- package/dist-types/ts3.4/runtimeConfig.d.ts +1 -1
- package/dist-types/ts3.4/runtimeConfig.native.d.ts +1 -1
- package/package.json +28 -28
|
@@ -8,6 +8,8 @@ const smithy_client_1 = require("@aws-sdk/smithy-client");
|
|
|
8
8
|
const entities_1 = require("entities");
|
|
9
9
|
const fast_xml_parser_1 = require("fast-xml-parser");
|
|
10
10
|
const uuid_1 = require("uuid");
|
|
11
|
+
const CloudFormationServiceException_1 = require("../models/CloudFormationServiceException");
|
|
12
|
+
const models_0_1 = require("../models/models_0");
|
|
11
13
|
const serializeAws_queryActivateTypeCommand = async (input, context) => {
|
|
12
14
|
const headers = {
|
|
13
15
|
"content-type": "application/x-www-form-urlencoded",
|
|
@@ -891,35 +893,19 @@ const deserializeAws_queryActivateTypeCommandError = async (output, context) =>
|
|
|
891
893
|
switch (errorCode) {
|
|
892
894
|
case "CFNRegistryException":
|
|
893
895
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
894
|
-
|
|
895
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
896
|
-
name: errorCode,
|
|
897
|
-
$metadata: deserializeMetadata(output),
|
|
898
|
-
};
|
|
899
|
-
break;
|
|
896
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
900
897
|
case "TypeNotFoundException":
|
|
901
898
|
case "com.amazonaws.cloudformation#TypeNotFoundException":
|
|
902
|
-
|
|
903
|
-
...(await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)),
|
|
904
|
-
name: errorCode,
|
|
905
|
-
$metadata: deserializeMetadata(output),
|
|
906
|
-
};
|
|
907
|
-
break;
|
|
899
|
+
throw await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context);
|
|
908
900
|
default:
|
|
909
901
|
const parsedBody = parsedOutput.body;
|
|
910
|
-
|
|
911
|
-
|
|
912
|
-
...parsedBody.Error,
|
|
913
|
-
name: `${errorCode}`,
|
|
914
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
902
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
903
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
915
904
|
$fault: "client",
|
|
916
905
|
$metadata: deserializeMetadata(output),
|
|
917
|
-
};
|
|
906
|
+
});
|
|
907
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
918
908
|
}
|
|
919
|
-
const message = response.message || response.Message || errorCode;
|
|
920
|
-
response.message = message;
|
|
921
|
-
delete response.Message;
|
|
922
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
923
909
|
};
|
|
924
910
|
const deserializeAws_queryBatchDescribeTypeConfigurationsCommand = async (output, context) => {
|
|
925
911
|
if (output.statusCode >= 300) {
|
|
@@ -946,35 +932,19 @@ const deserializeAws_queryBatchDescribeTypeConfigurationsCommandError = async (o
|
|
|
946
932
|
switch (errorCode) {
|
|
947
933
|
case "CFNRegistryException":
|
|
948
934
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
949
|
-
|
|
950
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
951
|
-
name: errorCode,
|
|
952
|
-
$metadata: deserializeMetadata(output),
|
|
953
|
-
};
|
|
954
|
-
break;
|
|
935
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
955
936
|
case "TypeConfigurationNotFoundException":
|
|
956
937
|
case "com.amazonaws.cloudformation#TypeConfigurationNotFoundException":
|
|
957
|
-
|
|
958
|
-
...(await deserializeAws_queryTypeConfigurationNotFoundExceptionResponse(parsedOutput, context)),
|
|
959
|
-
name: errorCode,
|
|
960
|
-
$metadata: deserializeMetadata(output),
|
|
961
|
-
};
|
|
962
|
-
break;
|
|
938
|
+
throw await deserializeAws_queryTypeConfigurationNotFoundExceptionResponse(parsedOutput, context);
|
|
963
939
|
default:
|
|
964
940
|
const parsedBody = parsedOutput.body;
|
|
965
|
-
|
|
966
|
-
|
|
967
|
-
...parsedBody.Error,
|
|
968
|
-
name: `${errorCode}`,
|
|
969
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
941
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
942
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
970
943
|
$fault: "client",
|
|
971
944
|
$metadata: deserializeMetadata(output),
|
|
972
|
-
};
|
|
945
|
+
});
|
|
946
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
973
947
|
}
|
|
974
|
-
const message = response.message || response.Message || errorCode;
|
|
975
|
-
response.message = message;
|
|
976
|
-
delete response.Message;
|
|
977
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
978
948
|
};
|
|
979
949
|
const deserializeAws_queryCancelUpdateStackCommand = async (output, context) => {
|
|
980
950
|
if (output.statusCode >= 300) {
|
|
@@ -998,27 +968,16 @@ const deserializeAws_queryCancelUpdateStackCommandError = async (output, context
|
|
|
998
968
|
switch (errorCode) {
|
|
999
969
|
case "TokenAlreadyExistsException":
|
|
1000
970
|
case "com.amazonaws.cloudformation#TokenAlreadyExistsException":
|
|
1001
|
-
|
|
1002
|
-
...(await deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)),
|
|
1003
|
-
name: errorCode,
|
|
1004
|
-
$metadata: deserializeMetadata(output),
|
|
1005
|
-
};
|
|
1006
|
-
break;
|
|
971
|
+
throw await deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context);
|
|
1007
972
|
default:
|
|
1008
973
|
const parsedBody = parsedOutput.body;
|
|
1009
|
-
|
|
1010
|
-
|
|
1011
|
-
...parsedBody.Error,
|
|
1012
|
-
name: `${errorCode}`,
|
|
1013
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
974
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
975
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1014
976
|
$fault: "client",
|
|
1015
977
|
$metadata: deserializeMetadata(output),
|
|
1016
|
-
};
|
|
978
|
+
});
|
|
979
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1017
980
|
}
|
|
1018
|
-
const message = response.message || response.Message || errorCode;
|
|
1019
|
-
response.message = message;
|
|
1020
|
-
delete response.Message;
|
|
1021
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1022
981
|
};
|
|
1023
982
|
const deserializeAws_queryContinueUpdateRollbackCommand = async (output, context) => {
|
|
1024
983
|
if (output.statusCode >= 300) {
|
|
@@ -1045,27 +1004,16 @@ const deserializeAws_queryContinueUpdateRollbackCommandError = async (output, co
|
|
|
1045
1004
|
switch (errorCode) {
|
|
1046
1005
|
case "TokenAlreadyExistsException":
|
|
1047
1006
|
case "com.amazonaws.cloudformation#TokenAlreadyExistsException":
|
|
1048
|
-
|
|
1049
|
-
...(await deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)),
|
|
1050
|
-
name: errorCode,
|
|
1051
|
-
$metadata: deserializeMetadata(output),
|
|
1052
|
-
};
|
|
1053
|
-
break;
|
|
1007
|
+
throw await deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context);
|
|
1054
1008
|
default:
|
|
1055
1009
|
const parsedBody = parsedOutput.body;
|
|
1056
|
-
|
|
1057
|
-
|
|
1058
|
-
...parsedBody.Error,
|
|
1059
|
-
name: `${errorCode}`,
|
|
1060
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1010
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1011
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1061
1012
|
$fault: "client",
|
|
1062
1013
|
$metadata: deserializeMetadata(output),
|
|
1063
|
-
};
|
|
1014
|
+
});
|
|
1015
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1064
1016
|
}
|
|
1065
|
-
const message = response.message || response.Message || errorCode;
|
|
1066
|
-
response.message = message;
|
|
1067
|
-
delete response.Message;
|
|
1068
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1069
1017
|
};
|
|
1070
1018
|
const deserializeAws_queryCreateChangeSetCommand = async (output, context) => {
|
|
1071
1019
|
if (output.statusCode >= 300) {
|
|
@@ -1092,43 +1040,22 @@ const deserializeAws_queryCreateChangeSetCommandError = async (output, context)
|
|
|
1092
1040
|
switch (errorCode) {
|
|
1093
1041
|
case "AlreadyExistsException":
|
|
1094
1042
|
case "com.amazonaws.cloudformation#AlreadyExistsException":
|
|
1095
|
-
|
|
1096
|
-
...(await deserializeAws_queryAlreadyExistsExceptionResponse(parsedOutput, context)),
|
|
1097
|
-
name: errorCode,
|
|
1098
|
-
$metadata: deserializeMetadata(output),
|
|
1099
|
-
};
|
|
1100
|
-
break;
|
|
1043
|
+
throw await deserializeAws_queryAlreadyExistsExceptionResponse(parsedOutput, context);
|
|
1101
1044
|
case "InsufficientCapabilitiesException":
|
|
1102
1045
|
case "com.amazonaws.cloudformation#InsufficientCapabilitiesException":
|
|
1103
|
-
|
|
1104
|
-
...(await deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context)),
|
|
1105
|
-
name: errorCode,
|
|
1106
|
-
$metadata: deserializeMetadata(output),
|
|
1107
|
-
};
|
|
1108
|
-
break;
|
|
1046
|
+
throw await deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context);
|
|
1109
1047
|
case "LimitExceededException":
|
|
1110
1048
|
case "com.amazonaws.cloudformation#LimitExceededException":
|
|
1111
|
-
|
|
1112
|
-
...(await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context)),
|
|
1113
|
-
name: errorCode,
|
|
1114
|
-
$metadata: deserializeMetadata(output),
|
|
1115
|
-
};
|
|
1116
|
-
break;
|
|
1049
|
+
throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
|
|
1117
1050
|
default:
|
|
1118
1051
|
const parsedBody = parsedOutput.body;
|
|
1119
|
-
|
|
1120
|
-
|
|
1121
|
-
...parsedBody.Error,
|
|
1122
|
-
name: `${errorCode}`,
|
|
1123
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1052
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1053
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1124
1054
|
$fault: "client",
|
|
1125
1055
|
$metadata: deserializeMetadata(output),
|
|
1126
|
-
};
|
|
1056
|
+
});
|
|
1057
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1127
1058
|
}
|
|
1128
|
-
const message = response.message || response.Message || errorCode;
|
|
1129
|
-
response.message = message;
|
|
1130
|
-
delete response.Message;
|
|
1131
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1132
1059
|
};
|
|
1133
1060
|
const deserializeAws_queryCreateStackCommand = async (output, context) => {
|
|
1134
1061
|
if (output.statusCode >= 300) {
|
|
@@ -1155,51 +1082,25 @@ const deserializeAws_queryCreateStackCommandError = async (output, context) => {
|
|
|
1155
1082
|
switch (errorCode) {
|
|
1156
1083
|
case "AlreadyExistsException":
|
|
1157
1084
|
case "com.amazonaws.cloudformation#AlreadyExistsException":
|
|
1158
|
-
|
|
1159
|
-
...(await deserializeAws_queryAlreadyExistsExceptionResponse(parsedOutput, context)),
|
|
1160
|
-
name: errorCode,
|
|
1161
|
-
$metadata: deserializeMetadata(output),
|
|
1162
|
-
};
|
|
1163
|
-
break;
|
|
1085
|
+
throw await deserializeAws_queryAlreadyExistsExceptionResponse(parsedOutput, context);
|
|
1164
1086
|
case "InsufficientCapabilitiesException":
|
|
1165
1087
|
case "com.amazonaws.cloudformation#InsufficientCapabilitiesException":
|
|
1166
|
-
|
|
1167
|
-
...(await deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context)),
|
|
1168
|
-
name: errorCode,
|
|
1169
|
-
$metadata: deserializeMetadata(output),
|
|
1170
|
-
};
|
|
1171
|
-
break;
|
|
1088
|
+
throw await deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context);
|
|
1172
1089
|
case "LimitExceededException":
|
|
1173
1090
|
case "com.amazonaws.cloudformation#LimitExceededException":
|
|
1174
|
-
|
|
1175
|
-
...(await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context)),
|
|
1176
|
-
name: errorCode,
|
|
1177
|
-
$metadata: deserializeMetadata(output),
|
|
1178
|
-
};
|
|
1179
|
-
break;
|
|
1091
|
+
throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
|
|
1180
1092
|
case "TokenAlreadyExistsException":
|
|
1181
1093
|
case "com.amazonaws.cloudformation#TokenAlreadyExistsException":
|
|
1182
|
-
|
|
1183
|
-
...(await deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)),
|
|
1184
|
-
name: errorCode,
|
|
1185
|
-
$metadata: deserializeMetadata(output),
|
|
1186
|
-
};
|
|
1187
|
-
break;
|
|
1094
|
+
throw await deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context);
|
|
1188
1095
|
default:
|
|
1189
1096
|
const parsedBody = parsedOutput.body;
|
|
1190
|
-
|
|
1191
|
-
|
|
1192
|
-
...parsedBody.Error,
|
|
1193
|
-
name: `${errorCode}`,
|
|
1194
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1097
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1098
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1195
1099
|
$fault: "client",
|
|
1196
1100
|
$metadata: deserializeMetadata(output),
|
|
1197
|
-
};
|
|
1101
|
+
});
|
|
1102
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1198
1103
|
}
|
|
1199
|
-
const message = response.message || response.Message || errorCode;
|
|
1200
|
-
response.message = message;
|
|
1201
|
-
delete response.Message;
|
|
1202
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1203
1104
|
};
|
|
1204
1105
|
const deserializeAws_queryCreateStackInstancesCommand = async (output, context) => {
|
|
1205
1106
|
if (output.statusCode >= 300) {
|
|
@@ -1226,67 +1127,31 @@ const deserializeAws_queryCreateStackInstancesCommandError = async (output, cont
|
|
|
1226
1127
|
switch (errorCode) {
|
|
1227
1128
|
case "InvalidOperationException":
|
|
1228
1129
|
case "com.amazonaws.cloudformation#InvalidOperationException":
|
|
1229
|
-
|
|
1230
|
-
...(await deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)),
|
|
1231
|
-
name: errorCode,
|
|
1232
|
-
$metadata: deserializeMetadata(output),
|
|
1233
|
-
};
|
|
1234
|
-
break;
|
|
1130
|
+
throw await deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context);
|
|
1235
1131
|
case "LimitExceededException":
|
|
1236
1132
|
case "com.amazonaws.cloudformation#LimitExceededException":
|
|
1237
|
-
|
|
1238
|
-
...(await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context)),
|
|
1239
|
-
name: errorCode,
|
|
1240
|
-
$metadata: deserializeMetadata(output),
|
|
1241
|
-
};
|
|
1242
|
-
break;
|
|
1133
|
+
throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
|
|
1243
1134
|
case "OperationIdAlreadyExistsException":
|
|
1244
1135
|
case "com.amazonaws.cloudformation#OperationIdAlreadyExistsException":
|
|
1245
|
-
|
|
1246
|
-
...(await deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context)),
|
|
1247
|
-
name: errorCode,
|
|
1248
|
-
$metadata: deserializeMetadata(output),
|
|
1249
|
-
};
|
|
1250
|
-
break;
|
|
1136
|
+
throw await deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context);
|
|
1251
1137
|
case "OperationInProgressException":
|
|
1252
1138
|
case "com.amazonaws.cloudformation#OperationInProgressException":
|
|
1253
|
-
|
|
1254
|
-
...(await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)),
|
|
1255
|
-
name: errorCode,
|
|
1256
|
-
$metadata: deserializeMetadata(output),
|
|
1257
|
-
};
|
|
1258
|
-
break;
|
|
1139
|
+
throw await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context);
|
|
1259
1140
|
case "StackSetNotFoundException":
|
|
1260
1141
|
case "com.amazonaws.cloudformation#StackSetNotFoundException":
|
|
1261
|
-
|
|
1262
|
-
...(await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
1263
|
-
name: errorCode,
|
|
1264
|
-
$metadata: deserializeMetadata(output),
|
|
1265
|
-
};
|
|
1266
|
-
break;
|
|
1142
|
+
throw await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context);
|
|
1267
1143
|
case "StaleRequestException":
|
|
1268
1144
|
case "com.amazonaws.cloudformation#StaleRequestException":
|
|
1269
|
-
|
|
1270
|
-
...(await deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context)),
|
|
1271
|
-
name: errorCode,
|
|
1272
|
-
$metadata: deserializeMetadata(output),
|
|
1273
|
-
};
|
|
1274
|
-
break;
|
|
1145
|
+
throw await deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context);
|
|
1275
1146
|
default:
|
|
1276
1147
|
const parsedBody = parsedOutput.body;
|
|
1277
|
-
|
|
1278
|
-
|
|
1279
|
-
...parsedBody.Error,
|
|
1280
|
-
name: `${errorCode}`,
|
|
1281
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1148
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1149
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1282
1150
|
$fault: "client",
|
|
1283
1151
|
$metadata: deserializeMetadata(output),
|
|
1284
|
-
};
|
|
1152
|
+
});
|
|
1153
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1285
1154
|
}
|
|
1286
|
-
const message = response.message || response.Message || errorCode;
|
|
1287
|
-
response.message = message;
|
|
1288
|
-
delete response.Message;
|
|
1289
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1290
1155
|
};
|
|
1291
1156
|
const deserializeAws_queryCreateStackSetCommand = async (output, context) => {
|
|
1292
1157
|
if (output.statusCode >= 300) {
|
|
@@ -1313,43 +1178,22 @@ const deserializeAws_queryCreateStackSetCommandError = async (output, context) =
|
|
|
1313
1178
|
switch (errorCode) {
|
|
1314
1179
|
case "CreatedButModifiedException":
|
|
1315
1180
|
case "com.amazonaws.cloudformation#CreatedButModifiedException":
|
|
1316
|
-
|
|
1317
|
-
...(await deserializeAws_queryCreatedButModifiedExceptionResponse(parsedOutput, context)),
|
|
1318
|
-
name: errorCode,
|
|
1319
|
-
$metadata: deserializeMetadata(output),
|
|
1320
|
-
};
|
|
1321
|
-
break;
|
|
1181
|
+
throw await deserializeAws_queryCreatedButModifiedExceptionResponse(parsedOutput, context);
|
|
1322
1182
|
case "LimitExceededException":
|
|
1323
1183
|
case "com.amazonaws.cloudformation#LimitExceededException":
|
|
1324
|
-
|
|
1325
|
-
...(await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context)),
|
|
1326
|
-
name: errorCode,
|
|
1327
|
-
$metadata: deserializeMetadata(output),
|
|
1328
|
-
};
|
|
1329
|
-
break;
|
|
1184
|
+
throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
|
|
1330
1185
|
case "NameAlreadyExistsException":
|
|
1331
1186
|
case "com.amazonaws.cloudformation#NameAlreadyExistsException":
|
|
1332
|
-
|
|
1333
|
-
...(await deserializeAws_queryNameAlreadyExistsExceptionResponse(parsedOutput, context)),
|
|
1334
|
-
name: errorCode,
|
|
1335
|
-
$metadata: deserializeMetadata(output),
|
|
1336
|
-
};
|
|
1337
|
-
break;
|
|
1187
|
+
throw await deserializeAws_queryNameAlreadyExistsExceptionResponse(parsedOutput, context);
|
|
1338
1188
|
default:
|
|
1339
1189
|
const parsedBody = parsedOutput.body;
|
|
1340
|
-
|
|
1341
|
-
|
|
1342
|
-
...parsedBody.Error,
|
|
1343
|
-
name: `${errorCode}`,
|
|
1344
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1190
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1191
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1345
1192
|
$fault: "client",
|
|
1346
1193
|
$metadata: deserializeMetadata(output),
|
|
1347
|
-
};
|
|
1194
|
+
});
|
|
1195
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1348
1196
|
}
|
|
1349
|
-
const message = response.message || response.Message || errorCode;
|
|
1350
|
-
response.message = message;
|
|
1351
|
-
delete response.Message;
|
|
1352
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1353
1197
|
};
|
|
1354
1198
|
const deserializeAws_queryDeactivateTypeCommand = async (output, context) => {
|
|
1355
1199
|
if (output.statusCode >= 300) {
|
|
@@ -1376,35 +1220,19 @@ const deserializeAws_queryDeactivateTypeCommandError = async (output, context) =
|
|
|
1376
1220
|
switch (errorCode) {
|
|
1377
1221
|
case "CFNRegistryException":
|
|
1378
1222
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
1379
|
-
|
|
1380
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
1381
|
-
name: errorCode,
|
|
1382
|
-
$metadata: deserializeMetadata(output),
|
|
1383
|
-
};
|
|
1384
|
-
break;
|
|
1223
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
1385
1224
|
case "TypeNotFoundException":
|
|
1386
1225
|
case "com.amazonaws.cloudformation#TypeNotFoundException":
|
|
1387
|
-
|
|
1388
|
-
...(await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)),
|
|
1389
|
-
name: errorCode,
|
|
1390
|
-
$metadata: deserializeMetadata(output),
|
|
1391
|
-
};
|
|
1392
|
-
break;
|
|
1226
|
+
throw await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context);
|
|
1393
1227
|
default:
|
|
1394
1228
|
const parsedBody = parsedOutput.body;
|
|
1395
|
-
|
|
1396
|
-
|
|
1397
|
-
...parsedBody.Error,
|
|
1398
|
-
name: `${errorCode}`,
|
|
1399
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1229
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1230
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1400
1231
|
$fault: "client",
|
|
1401
1232
|
$metadata: deserializeMetadata(output),
|
|
1402
|
-
};
|
|
1233
|
+
});
|
|
1234
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1403
1235
|
}
|
|
1404
|
-
const message = response.message || response.Message || errorCode;
|
|
1405
|
-
response.message = message;
|
|
1406
|
-
delete response.Message;
|
|
1407
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1408
1236
|
};
|
|
1409
1237
|
const deserializeAws_queryDeleteChangeSetCommand = async (output, context) => {
|
|
1410
1238
|
if (output.statusCode >= 300) {
|
|
@@ -1431,27 +1259,16 @@ const deserializeAws_queryDeleteChangeSetCommandError = async (output, context)
|
|
|
1431
1259
|
switch (errorCode) {
|
|
1432
1260
|
case "InvalidChangeSetStatusException":
|
|
1433
1261
|
case "com.amazonaws.cloudformation#InvalidChangeSetStatusException":
|
|
1434
|
-
|
|
1435
|
-
...(await deserializeAws_queryInvalidChangeSetStatusExceptionResponse(parsedOutput, context)),
|
|
1436
|
-
name: errorCode,
|
|
1437
|
-
$metadata: deserializeMetadata(output),
|
|
1438
|
-
};
|
|
1439
|
-
break;
|
|
1262
|
+
throw await deserializeAws_queryInvalidChangeSetStatusExceptionResponse(parsedOutput, context);
|
|
1440
1263
|
default:
|
|
1441
1264
|
const parsedBody = parsedOutput.body;
|
|
1442
|
-
|
|
1443
|
-
|
|
1444
|
-
...parsedBody.Error,
|
|
1445
|
-
name: `${errorCode}`,
|
|
1446
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1265
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1266
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1447
1267
|
$fault: "client",
|
|
1448
1268
|
$metadata: deserializeMetadata(output),
|
|
1449
|
-
};
|
|
1269
|
+
});
|
|
1270
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1450
1271
|
}
|
|
1451
|
-
const message = response.message || response.Message || errorCode;
|
|
1452
|
-
response.message = message;
|
|
1453
|
-
delete response.Message;
|
|
1454
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1455
1272
|
};
|
|
1456
1273
|
const deserializeAws_queryDeleteStackCommand = async (output, context) => {
|
|
1457
1274
|
if (output.statusCode >= 300) {
|
|
@@ -1475,27 +1292,16 @@ const deserializeAws_queryDeleteStackCommandError = async (output, context) => {
|
|
|
1475
1292
|
switch (errorCode) {
|
|
1476
1293
|
case "TokenAlreadyExistsException":
|
|
1477
1294
|
case "com.amazonaws.cloudformation#TokenAlreadyExistsException":
|
|
1478
|
-
|
|
1479
|
-
...(await deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)),
|
|
1480
|
-
name: errorCode,
|
|
1481
|
-
$metadata: deserializeMetadata(output),
|
|
1482
|
-
};
|
|
1483
|
-
break;
|
|
1295
|
+
throw await deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context);
|
|
1484
1296
|
default:
|
|
1485
1297
|
const parsedBody = parsedOutput.body;
|
|
1486
|
-
|
|
1487
|
-
|
|
1488
|
-
...parsedBody.Error,
|
|
1489
|
-
name: `${errorCode}`,
|
|
1490
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1298
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1299
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1491
1300
|
$fault: "client",
|
|
1492
1301
|
$metadata: deserializeMetadata(output),
|
|
1493
|
-
};
|
|
1302
|
+
});
|
|
1303
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1494
1304
|
}
|
|
1495
|
-
const message = response.message || response.Message || errorCode;
|
|
1496
|
-
response.message = message;
|
|
1497
|
-
delete response.Message;
|
|
1498
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1499
1305
|
};
|
|
1500
1306
|
const deserializeAws_queryDeleteStackInstancesCommand = async (output, context) => {
|
|
1501
1307
|
if (output.statusCode >= 300) {
|
|
@@ -1522,59 +1328,28 @@ const deserializeAws_queryDeleteStackInstancesCommandError = async (output, cont
|
|
|
1522
1328
|
switch (errorCode) {
|
|
1523
1329
|
case "InvalidOperationException":
|
|
1524
1330
|
case "com.amazonaws.cloudformation#InvalidOperationException":
|
|
1525
|
-
|
|
1526
|
-
...(await deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)),
|
|
1527
|
-
name: errorCode,
|
|
1528
|
-
$metadata: deserializeMetadata(output),
|
|
1529
|
-
};
|
|
1530
|
-
break;
|
|
1331
|
+
throw await deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context);
|
|
1531
1332
|
case "OperationIdAlreadyExistsException":
|
|
1532
1333
|
case "com.amazonaws.cloudformation#OperationIdAlreadyExistsException":
|
|
1533
|
-
|
|
1534
|
-
...(await deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context)),
|
|
1535
|
-
name: errorCode,
|
|
1536
|
-
$metadata: deserializeMetadata(output),
|
|
1537
|
-
};
|
|
1538
|
-
break;
|
|
1334
|
+
throw await deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context);
|
|
1539
1335
|
case "OperationInProgressException":
|
|
1540
1336
|
case "com.amazonaws.cloudformation#OperationInProgressException":
|
|
1541
|
-
|
|
1542
|
-
...(await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)),
|
|
1543
|
-
name: errorCode,
|
|
1544
|
-
$metadata: deserializeMetadata(output),
|
|
1545
|
-
};
|
|
1546
|
-
break;
|
|
1337
|
+
throw await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context);
|
|
1547
1338
|
case "StackSetNotFoundException":
|
|
1548
1339
|
case "com.amazonaws.cloudformation#StackSetNotFoundException":
|
|
1549
|
-
|
|
1550
|
-
...(await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
1551
|
-
name: errorCode,
|
|
1552
|
-
$metadata: deserializeMetadata(output),
|
|
1553
|
-
};
|
|
1554
|
-
break;
|
|
1340
|
+
throw await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context);
|
|
1555
1341
|
case "StaleRequestException":
|
|
1556
1342
|
case "com.amazonaws.cloudformation#StaleRequestException":
|
|
1557
|
-
|
|
1558
|
-
...(await deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context)),
|
|
1559
|
-
name: errorCode,
|
|
1560
|
-
$metadata: deserializeMetadata(output),
|
|
1561
|
-
};
|
|
1562
|
-
break;
|
|
1343
|
+
throw await deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context);
|
|
1563
1344
|
default:
|
|
1564
1345
|
const parsedBody = parsedOutput.body;
|
|
1565
|
-
|
|
1566
|
-
|
|
1567
|
-
...parsedBody.Error,
|
|
1568
|
-
name: `${errorCode}`,
|
|
1569
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1346
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1347
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1570
1348
|
$fault: "client",
|
|
1571
1349
|
$metadata: deserializeMetadata(output),
|
|
1572
|
-
};
|
|
1350
|
+
});
|
|
1351
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1573
1352
|
}
|
|
1574
|
-
const message = response.message || response.Message || errorCode;
|
|
1575
|
-
response.message = message;
|
|
1576
|
-
delete response.Message;
|
|
1577
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1578
1353
|
};
|
|
1579
1354
|
const deserializeAws_queryDeleteStackSetCommand = async (output, context) => {
|
|
1580
1355
|
if (output.statusCode >= 300) {
|
|
@@ -1601,35 +1376,19 @@ const deserializeAws_queryDeleteStackSetCommandError = async (output, context) =
|
|
|
1601
1376
|
switch (errorCode) {
|
|
1602
1377
|
case "OperationInProgressException":
|
|
1603
1378
|
case "com.amazonaws.cloudformation#OperationInProgressException":
|
|
1604
|
-
|
|
1605
|
-
...(await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)),
|
|
1606
|
-
name: errorCode,
|
|
1607
|
-
$metadata: deserializeMetadata(output),
|
|
1608
|
-
};
|
|
1609
|
-
break;
|
|
1379
|
+
throw await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context);
|
|
1610
1380
|
case "StackSetNotEmptyException":
|
|
1611
1381
|
case "com.amazonaws.cloudformation#StackSetNotEmptyException":
|
|
1612
|
-
|
|
1613
|
-
...(await deserializeAws_queryStackSetNotEmptyExceptionResponse(parsedOutput, context)),
|
|
1614
|
-
name: errorCode,
|
|
1615
|
-
$metadata: deserializeMetadata(output),
|
|
1616
|
-
};
|
|
1617
|
-
break;
|
|
1382
|
+
throw await deserializeAws_queryStackSetNotEmptyExceptionResponse(parsedOutput, context);
|
|
1618
1383
|
default:
|
|
1619
1384
|
const parsedBody = parsedOutput.body;
|
|
1620
|
-
|
|
1621
|
-
|
|
1622
|
-
...parsedBody.Error,
|
|
1623
|
-
name: `${errorCode}`,
|
|
1624
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1385
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1386
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1625
1387
|
$fault: "client",
|
|
1626
1388
|
$metadata: deserializeMetadata(output),
|
|
1627
|
-
};
|
|
1389
|
+
});
|
|
1390
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1628
1391
|
}
|
|
1629
|
-
const message = response.message || response.Message || errorCode;
|
|
1630
|
-
response.message = message;
|
|
1631
|
-
delete response.Message;
|
|
1632
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1633
1392
|
};
|
|
1634
1393
|
const deserializeAws_queryDeregisterTypeCommand = async (output, context) => {
|
|
1635
1394
|
if (output.statusCode >= 300) {
|
|
@@ -1656,35 +1415,19 @@ const deserializeAws_queryDeregisterTypeCommandError = async (output, context) =
|
|
|
1656
1415
|
switch (errorCode) {
|
|
1657
1416
|
case "CFNRegistryException":
|
|
1658
1417
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
1659
|
-
|
|
1660
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
1661
|
-
name: errorCode,
|
|
1662
|
-
$metadata: deserializeMetadata(output),
|
|
1663
|
-
};
|
|
1664
|
-
break;
|
|
1418
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
1665
1419
|
case "TypeNotFoundException":
|
|
1666
1420
|
case "com.amazonaws.cloudformation#TypeNotFoundException":
|
|
1667
|
-
|
|
1668
|
-
...(await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)),
|
|
1669
|
-
name: errorCode,
|
|
1670
|
-
$metadata: deserializeMetadata(output),
|
|
1671
|
-
};
|
|
1672
|
-
break;
|
|
1421
|
+
throw await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context);
|
|
1673
1422
|
default:
|
|
1674
1423
|
const parsedBody = parsedOutput.body;
|
|
1675
|
-
|
|
1676
|
-
|
|
1677
|
-
...parsedBody.Error,
|
|
1678
|
-
name: `${errorCode}`,
|
|
1679
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1424
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1425
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1680
1426
|
$fault: "client",
|
|
1681
1427
|
$metadata: deserializeMetadata(output),
|
|
1682
|
-
};
|
|
1428
|
+
});
|
|
1429
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1683
1430
|
}
|
|
1684
|
-
const message = response.message || response.Message || errorCode;
|
|
1685
|
-
response.message = message;
|
|
1686
|
-
delete response.Message;
|
|
1687
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1688
1431
|
};
|
|
1689
1432
|
const deserializeAws_queryDescribeAccountLimitsCommand = async (output, context) => {
|
|
1690
1433
|
if (output.statusCode >= 300) {
|
|
@@ -1711,19 +1454,13 @@ const deserializeAws_queryDescribeAccountLimitsCommandError = async (output, con
|
|
|
1711
1454
|
switch (errorCode) {
|
|
1712
1455
|
default:
|
|
1713
1456
|
const parsedBody = parsedOutput.body;
|
|
1714
|
-
|
|
1715
|
-
|
|
1716
|
-
...parsedBody.Error,
|
|
1717
|
-
name: `${errorCode}`,
|
|
1718
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1457
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1458
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1719
1459
|
$fault: "client",
|
|
1720
1460
|
$metadata: deserializeMetadata(output),
|
|
1721
|
-
};
|
|
1461
|
+
});
|
|
1462
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1722
1463
|
}
|
|
1723
|
-
const message = response.message || response.Message || errorCode;
|
|
1724
|
-
response.message = message;
|
|
1725
|
-
delete response.Message;
|
|
1726
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1727
1464
|
};
|
|
1728
1465
|
const deserializeAws_queryDescribeChangeSetCommand = async (output, context) => {
|
|
1729
1466
|
if (output.statusCode >= 300) {
|
|
@@ -1750,27 +1487,16 @@ const deserializeAws_queryDescribeChangeSetCommandError = async (output, context
|
|
|
1750
1487
|
switch (errorCode) {
|
|
1751
1488
|
case "ChangeSetNotFoundException":
|
|
1752
1489
|
case "com.amazonaws.cloudformation#ChangeSetNotFoundException":
|
|
1753
|
-
|
|
1754
|
-
...(await deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
1755
|
-
name: errorCode,
|
|
1756
|
-
$metadata: deserializeMetadata(output),
|
|
1757
|
-
};
|
|
1758
|
-
break;
|
|
1490
|
+
throw await deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context);
|
|
1759
1491
|
default:
|
|
1760
1492
|
const parsedBody = parsedOutput.body;
|
|
1761
|
-
|
|
1762
|
-
|
|
1763
|
-
...parsedBody.Error,
|
|
1764
|
-
name: `${errorCode}`,
|
|
1765
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1493
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1494
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1766
1495
|
$fault: "client",
|
|
1767
1496
|
$metadata: deserializeMetadata(output),
|
|
1768
|
-
};
|
|
1497
|
+
});
|
|
1498
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1769
1499
|
}
|
|
1770
|
-
const message = response.message || response.Message || errorCode;
|
|
1771
|
-
response.message = message;
|
|
1772
|
-
delete response.Message;
|
|
1773
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1774
1500
|
};
|
|
1775
1501
|
const deserializeAws_queryDescribeChangeSetHooksCommand = async (output, context) => {
|
|
1776
1502
|
if (output.statusCode >= 300) {
|
|
@@ -1797,27 +1523,16 @@ const deserializeAws_queryDescribeChangeSetHooksCommandError = async (output, co
|
|
|
1797
1523
|
switch (errorCode) {
|
|
1798
1524
|
case "ChangeSetNotFoundException":
|
|
1799
1525
|
case "com.amazonaws.cloudformation#ChangeSetNotFoundException":
|
|
1800
|
-
|
|
1801
|
-
...(await deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
1802
|
-
name: errorCode,
|
|
1803
|
-
$metadata: deserializeMetadata(output),
|
|
1804
|
-
};
|
|
1805
|
-
break;
|
|
1526
|
+
throw await deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context);
|
|
1806
1527
|
default:
|
|
1807
1528
|
const parsedBody = parsedOutput.body;
|
|
1808
|
-
|
|
1809
|
-
|
|
1810
|
-
...parsedBody.Error,
|
|
1811
|
-
name: `${errorCode}`,
|
|
1812
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1529
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1530
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1813
1531
|
$fault: "client",
|
|
1814
1532
|
$metadata: deserializeMetadata(output),
|
|
1815
|
-
};
|
|
1533
|
+
});
|
|
1534
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1816
1535
|
}
|
|
1817
|
-
const message = response.message || response.Message || errorCode;
|
|
1818
|
-
response.message = message;
|
|
1819
|
-
delete response.Message;
|
|
1820
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1821
1536
|
};
|
|
1822
1537
|
const deserializeAws_queryDescribePublisherCommand = async (output, context) => {
|
|
1823
1538
|
if (output.statusCode >= 300) {
|
|
@@ -1844,27 +1559,16 @@ const deserializeAws_queryDescribePublisherCommandError = async (output, context
|
|
|
1844
1559
|
switch (errorCode) {
|
|
1845
1560
|
case "CFNRegistryException":
|
|
1846
1561
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
1847
|
-
|
|
1848
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
1849
|
-
name: errorCode,
|
|
1850
|
-
$metadata: deserializeMetadata(output),
|
|
1851
|
-
};
|
|
1852
|
-
break;
|
|
1562
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
1853
1563
|
default:
|
|
1854
1564
|
const parsedBody = parsedOutput.body;
|
|
1855
|
-
|
|
1856
|
-
|
|
1857
|
-
...parsedBody.Error,
|
|
1858
|
-
name: `${errorCode}`,
|
|
1859
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1565
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1566
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1860
1567
|
$fault: "client",
|
|
1861
1568
|
$metadata: deserializeMetadata(output),
|
|
1862
|
-
};
|
|
1569
|
+
});
|
|
1570
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1863
1571
|
}
|
|
1864
|
-
const message = response.message || response.Message || errorCode;
|
|
1865
|
-
response.message = message;
|
|
1866
|
-
delete response.Message;
|
|
1867
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1868
1572
|
};
|
|
1869
1573
|
const deserializeAws_queryDescribeStackDriftDetectionStatusCommand = async (output, context) => {
|
|
1870
1574
|
if (output.statusCode >= 300) {
|
|
@@ -1891,19 +1595,13 @@ const deserializeAws_queryDescribeStackDriftDetectionStatusCommandError = async
|
|
|
1891
1595
|
switch (errorCode) {
|
|
1892
1596
|
default:
|
|
1893
1597
|
const parsedBody = parsedOutput.body;
|
|
1894
|
-
|
|
1895
|
-
|
|
1896
|
-
...parsedBody.Error,
|
|
1897
|
-
name: `${errorCode}`,
|
|
1898
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1598
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1599
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1899
1600
|
$fault: "client",
|
|
1900
1601
|
$metadata: deserializeMetadata(output),
|
|
1901
|
-
};
|
|
1602
|
+
});
|
|
1603
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1902
1604
|
}
|
|
1903
|
-
const message = response.message || response.Message || errorCode;
|
|
1904
|
-
response.message = message;
|
|
1905
|
-
delete response.Message;
|
|
1906
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1907
1605
|
};
|
|
1908
1606
|
const deserializeAws_queryDescribeStackEventsCommand = async (output, context) => {
|
|
1909
1607
|
if (output.statusCode >= 300) {
|
|
@@ -1930,19 +1628,13 @@ const deserializeAws_queryDescribeStackEventsCommandError = async (output, conte
|
|
|
1930
1628
|
switch (errorCode) {
|
|
1931
1629
|
default:
|
|
1932
1630
|
const parsedBody = parsedOutput.body;
|
|
1933
|
-
|
|
1934
|
-
|
|
1935
|
-
...parsedBody.Error,
|
|
1936
|
-
name: `${errorCode}`,
|
|
1937
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1631
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1632
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1938
1633
|
$fault: "client",
|
|
1939
1634
|
$metadata: deserializeMetadata(output),
|
|
1940
|
-
};
|
|
1635
|
+
});
|
|
1636
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1941
1637
|
}
|
|
1942
|
-
const message = response.message || response.Message || errorCode;
|
|
1943
|
-
response.message = message;
|
|
1944
|
-
delete response.Message;
|
|
1945
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
1946
1638
|
};
|
|
1947
1639
|
const deserializeAws_queryDescribeStackInstanceCommand = async (output, context) => {
|
|
1948
1640
|
if (output.statusCode >= 300) {
|
|
@@ -1969,35 +1661,19 @@ const deserializeAws_queryDescribeStackInstanceCommandError = async (output, con
|
|
|
1969
1661
|
switch (errorCode) {
|
|
1970
1662
|
case "StackInstanceNotFoundException":
|
|
1971
1663
|
case "com.amazonaws.cloudformation#StackInstanceNotFoundException":
|
|
1972
|
-
|
|
1973
|
-
...(await deserializeAws_queryStackInstanceNotFoundExceptionResponse(parsedOutput, context)),
|
|
1974
|
-
name: errorCode,
|
|
1975
|
-
$metadata: deserializeMetadata(output),
|
|
1976
|
-
};
|
|
1977
|
-
break;
|
|
1664
|
+
throw await deserializeAws_queryStackInstanceNotFoundExceptionResponse(parsedOutput, context);
|
|
1978
1665
|
case "StackSetNotFoundException":
|
|
1979
1666
|
case "com.amazonaws.cloudformation#StackSetNotFoundException":
|
|
1980
|
-
|
|
1981
|
-
...(await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
1982
|
-
name: errorCode,
|
|
1983
|
-
$metadata: deserializeMetadata(output),
|
|
1984
|
-
};
|
|
1985
|
-
break;
|
|
1667
|
+
throw await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context);
|
|
1986
1668
|
default:
|
|
1987
1669
|
const parsedBody = parsedOutput.body;
|
|
1988
|
-
|
|
1989
|
-
|
|
1990
|
-
...parsedBody.Error,
|
|
1991
|
-
name: `${errorCode}`,
|
|
1992
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1670
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1671
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
1993
1672
|
$fault: "client",
|
|
1994
1673
|
$metadata: deserializeMetadata(output),
|
|
1995
|
-
};
|
|
1674
|
+
});
|
|
1675
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
1996
1676
|
}
|
|
1997
|
-
const message = response.message || response.Message || errorCode;
|
|
1998
|
-
response.message = message;
|
|
1999
|
-
delete response.Message;
|
|
2000
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2001
1677
|
};
|
|
2002
1678
|
const deserializeAws_queryDescribeStackResourceCommand = async (output, context) => {
|
|
2003
1679
|
if (output.statusCode >= 300) {
|
|
@@ -2024,19 +1700,13 @@ const deserializeAws_queryDescribeStackResourceCommandError = async (output, con
|
|
|
2024
1700
|
switch (errorCode) {
|
|
2025
1701
|
default:
|
|
2026
1702
|
const parsedBody = parsedOutput.body;
|
|
2027
|
-
|
|
2028
|
-
|
|
2029
|
-
...parsedBody.Error,
|
|
2030
|
-
name: `${errorCode}`,
|
|
2031
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1703
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1704
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2032
1705
|
$fault: "client",
|
|
2033
1706
|
$metadata: deserializeMetadata(output),
|
|
2034
|
-
};
|
|
1707
|
+
});
|
|
1708
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2035
1709
|
}
|
|
2036
|
-
const message = response.message || response.Message || errorCode;
|
|
2037
|
-
response.message = message;
|
|
2038
|
-
delete response.Message;
|
|
2039
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2040
1710
|
};
|
|
2041
1711
|
const deserializeAws_queryDescribeStackResourceDriftsCommand = async (output, context) => {
|
|
2042
1712
|
if (output.statusCode >= 300) {
|
|
@@ -2063,19 +1733,13 @@ const deserializeAws_queryDescribeStackResourceDriftsCommandError = async (outpu
|
|
|
2063
1733
|
switch (errorCode) {
|
|
2064
1734
|
default:
|
|
2065
1735
|
const parsedBody = parsedOutput.body;
|
|
2066
|
-
|
|
2067
|
-
|
|
2068
|
-
...parsedBody.Error,
|
|
2069
|
-
name: `${errorCode}`,
|
|
2070
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1736
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1737
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2071
1738
|
$fault: "client",
|
|
2072
1739
|
$metadata: deserializeMetadata(output),
|
|
2073
|
-
};
|
|
1740
|
+
});
|
|
1741
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2074
1742
|
}
|
|
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
1743
|
};
|
|
2080
1744
|
const deserializeAws_queryDescribeStackResourcesCommand = async (output, context) => {
|
|
2081
1745
|
if (output.statusCode >= 300) {
|
|
@@ -2102,19 +1766,13 @@ const deserializeAws_queryDescribeStackResourcesCommandError = async (output, co
|
|
|
2102
1766
|
switch (errorCode) {
|
|
2103
1767
|
default:
|
|
2104
1768
|
const parsedBody = parsedOutput.body;
|
|
2105
|
-
|
|
2106
|
-
|
|
2107
|
-
...parsedBody.Error,
|
|
2108
|
-
name: `${errorCode}`,
|
|
2109
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1769
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1770
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2110
1771
|
$fault: "client",
|
|
2111
1772
|
$metadata: deserializeMetadata(output),
|
|
2112
|
-
};
|
|
1773
|
+
});
|
|
1774
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2113
1775
|
}
|
|
2114
|
-
const message = response.message || response.Message || errorCode;
|
|
2115
|
-
response.message = message;
|
|
2116
|
-
delete response.Message;
|
|
2117
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2118
1776
|
};
|
|
2119
1777
|
const deserializeAws_queryDescribeStacksCommand = async (output, context) => {
|
|
2120
1778
|
if (output.statusCode >= 300) {
|
|
@@ -2141,19 +1799,13 @@ const deserializeAws_queryDescribeStacksCommandError = async (output, context) =
|
|
|
2141
1799
|
switch (errorCode) {
|
|
2142
1800
|
default:
|
|
2143
1801
|
const parsedBody = parsedOutput.body;
|
|
2144
|
-
|
|
2145
|
-
|
|
2146
|
-
...parsedBody.Error,
|
|
2147
|
-
name: `${errorCode}`,
|
|
2148
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1802
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1803
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2149
1804
|
$fault: "client",
|
|
2150
1805
|
$metadata: deserializeMetadata(output),
|
|
2151
|
-
};
|
|
1806
|
+
});
|
|
1807
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2152
1808
|
}
|
|
2153
|
-
const message = response.message || response.Message || errorCode;
|
|
2154
|
-
response.message = message;
|
|
2155
|
-
delete response.Message;
|
|
2156
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2157
1809
|
};
|
|
2158
1810
|
const deserializeAws_queryDescribeStackSetCommand = async (output, context) => {
|
|
2159
1811
|
if (output.statusCode >= 300) {
|
|
@@ -2180,27 +1832,16 @@ const deserializeAws_queryDescribeStackSetCommandError = async (output, context)
|
|
|
2180
1832
|
switch (errorCode) {
|
|
2181
1833
|
case "StackSetNotFoundException":
|
|
2182
1834
|
case "com.amazonaws.cloudformation#StackSetNotFoundException":
|
|
2183
|
-
|
|
2184
|
-
...(await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
2185
|
-
name: errorCode,
|
|
2186
|
-
$metadata: deserializeMetadata(output),
|
|
2187
|
-
};
|
|
2188
|
-
break;
|
|
1835
|
+
throw await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context);
|
|
2189
1836
|
default:
|
|
2190
1837
|
const parsedBody = parsedOutput.body;
|
|
2191
|
-
|
|
2192
|
-
|
|
2193
|
-
...parsedBody.Error,
|
|
2194
|
-
name: `${errorCode}`,
|
|
2195
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1838
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1839
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2196
1840
|
$fault: "client",
|
|
2197
1841
|
$metadata: deserializeMetadata(output),
|
|
2198
|
-
};
|
|
1842
|
+
});
|
|
1843
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2199
1844
|
}
|
|
2200
|
-
const message = response.message || response.Message || errorCode;
|
|
2201
|
-
response.message = message;
|
|
2202
|
-
delete response.Message;
|
|
2203
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2204
1845
|
};
|
|
2205
1846
|
const deserializeAws_queryDescribeStackSetOperationCommand = async (output, context) => {
|
|
2206
1847
|
if (output.statusCode >= 300) {
|
|
@@ -2227,35 +1868,19 @@ const deserializeAws_queryDescribeStackSetOperationCommandError = async (output,
|
|
|
2227
1868
|
switch (errorCode) {
|
|
2228
1869
|
case "OperationNotFoundException":
|
|
2229
1870
|
case "com.amazonaws.cloudformation#OperationNotFoundException":
|
|
2230
|
-
|
|
2231
|
-
...(await deserializeAws_queryOperationNotFoundExceptionResponse(parsedOutput, context)),
|
|
2232
|
-
name: errorCode,
|
|
2233
|
-
$metadata: deserializeMetadata(output),
|
|
2234
|
-
};
|
|
2235
|
-
break;
|
|
1871
|
+
throw await deserializeAws_queryOperationNotFoundExceptionResponse(parsedOutput, context);
|
|
2236
1872
|
case "StackSetNotFoundException":
|
|
2237
1873
|
case "com.amazonaws.cloudformation#StackSetNotFoundException":
|
|
2238
|
-
|
|
2239
|
-
...(await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
2240
|
-
name: errorCode,
|
|
2241
|
-
$metadata: deserializeMetadata(output),
|
|
2242
|
-
};
|
|
2243
|
-
break;
|
|
1874
|
+
throw await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context);
|
|
2244
1875
|
default:
|
|
2245
1876
|
const parsedBody = parsedOutput.body;
|
|
2246
|
-
|
|
2247
|
-
|
|
2248
|
-
...parsedBody.Error,
|
|
2249
|
-
name: `${errorCode}`,
|
|
2250
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1877
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1878
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2251
1879
|
$fault: "client",
|
|
2252
1880
|
$metadata: deserializeMetadata(output),
|
|
2253
|
-
};
|
|
1881
|
+
});
|
|
1882
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2254
1883
|
}
|
|
2255
|
-
const message = response.message || response.Message || errorCode;
|
|
2256
|
-
response.message = message;
|
|
2257
|
-
delete response.Message;
|
|
2258
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2259
1884
|
};
|
|
2260
1885
|
const deserializeAws_queryDescribeTypeCommand = async (output, context) => {
|
|
2261
1886
|
if (output.statusCode >= 300) {
|
|
@@ -2282,35 +1907,19 @@ const deserializeAws_queryDescribeTypeCommandError = async (output, context) =>
|
|
|
2282
1907
|
switch (errorCode) {
|
|
2283
1908
|
case "CFNRegistryException":
|
|
2284
1909
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
2285
|
-
|
|
2286
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
2287
|
-
name: errorCode,
|
|
2288
|
-
$metadata: deserializeMetadata(output),
|
|
2289
|
-
};
|
|
2290
|
-
break;
|
|
1910
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
2291
1911
|
case "TypeNotFoundException":
|
|
2292
1912
|
case "com.amazonaws.cloudformation#TypeNotFoundException":
|
|
2293
|
-
|
|
2294
|
-
...(await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)),
|
|
2295
|
-
name: errorCode,
|
|
2296
|
-
$metadata: deserializeMetadata(output),
|
|
2297
|
-
};
|
|
2298
|
-
break;
|
|
1913
|
+
throw await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context);
|
|
2299
1914
|
default:
|
|
2300
1915
|
const parsedBody = parsedOutput.body;
|
|
2301
|
-
|
|
2302
|
-
|
|
2303
|
-
...parsedBody.Error,
|
|
2304
|
-
name: `${errorCode}`,
|
|
2305
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1916
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1917
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2306
1918
|
$fault: "client",
|
|
2307
1919
|
$metadata: deserializeMetadata(output),
|
|
2308
|
-
};
|
|
1920
|
+
});
|
|
1921
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2309
1922
|
}
|
|
2310
|
-
const message = response.message || response.Message || errorCode;
|
|
2311
|
-
response.message = message;
|
|
2312
|
-
delete response.Message;
|
|
2313
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2314
1923
|
};
|
|
2315
1924
|
const deserializeAws_queryDescribeTypeRegistrationCommand = async (output, context) => {
|
|
2316
1925
|
if (output.statusCode >= 300) {
|
|
@@ -2337,27 +1946,16 @@ const deserializeAws_queryDescribeTypeRegistrationCommandError = async (output,
|
|
|
2337
1946
|
switch (errorCode) {
|
|
2338
1947
|
case "CFNRegistryException":
|
|
2339
1948
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
2340
|
-
|
|
2341
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
2342
|
-
name: errorCode,
|
|
2343
|
-
$metadata: deserializeMetadata(output),
|
|
2344
|
-
};
|
|
2345
|
-
break;
|
|
1949
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
2346
1950
|
default:
|
|
2347
1951
|
const parsedBody = parsedOutput.body;
|
|
2348
|
-
|
|
2349
|
-
|
|
2350
|
-
...parsedBody.Error,
|
|
2351
|
-
name: `${errorCode}`,
|
|
2352
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1952
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1953
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2353
1954
|
$fault: "client",
|
|
2354
1955
|
$metadata: deserializeMetadata(output),
|
|
2355
|
-
};
|
|
1956
|
+
});
|
|
1957
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2356
1958
|
}
|
|
2357
|
-
const message = response.message || response.Message || errorCode;
|
|
2358
|
-
response.message = message;
|
|
2359
|
-
delete response.Message;
|
|
2360
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2361
1959
|
};
|
|
2362
1960
|
const deserializeAws_queryDetectStackDriftCommand = async (output, context) => {
|
|
2363
1961
|
if (output.statusCode >= 300) {
|
|
@@ -2384,19 +1982,13 @@ const deserializeAws_queryDetectStackDriftCommandError = async (output, context)
|
|
|
2384
1982
|
switch (errorCode) {
|
|
2385
1983
|
default:
|
|
2386
1984
|
const parsedBody = parsedOutput.body;
|
|
2387
|
-
|
|
2388
|
-
|
|
2389
|
-
...parsedBody.Error,
|
|
2390
|
-
name: `${errorCode}`,
|
|
2391
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
1985
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
1986
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2392
1987
|
$fault: "client",
|
|
2393
1988
|
$metadata: deserializeMetadata(output),
|
|
2394
|
-
};
|
|
1989
|
+
});
|
|
1990
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2395
1991
|
}
|
|
2396
|
-
const message = response.message || response.Message || errorCode;
|
|
2397
|
-
response.message = message;
|
|
2398
|
-
delete response.Message;
|
|
2399
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2400
1992
|
};
|
|
2401
1993
|
const deserializeAws_queryDetectStackResourceDriftCommand = async (output, context) => {
|
|
2402
1994
|
if (output.statusCode >= 300) {
|
|
@@ -2423,19 +2015,13 @@ const deserializeAws_queryDetectStackResourceDriftCommandError = async (output,
|
|
|
2423
2015
|
switch (errorCode) {
|
|
2424
2016
|
default:
|
|
2425
2017
|
const parsedBody = parsedOutput.body;
|
|
2426
|
-
|
|
2427
|
-
|
|
2428
|
-
...parsedBody.Error,
|
|
2429
|
-
name: `${errorCode}`,
|
|
2430
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2018
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2019
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2431
2020
|
$fault: "client",
|
|
2432
2021
|
$metadata: deserializeMetadata(output),
|
|
2433
|
-
};
|
|
2022
|
+
});
|
|
2023
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2434
2024
|
}
|
|
2435
|
-
const message = response.message || response.Message || errorCode;
|
|
2436
|
-
response.message = message;
|
|
2437
|
-
delete response.Message;
|
|
2438
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2439
2025
|
};
|
|
2440
2026
|
const deserializeAws_queryDetectStackSetDriftCommand = async (output, context) => {
|
|
2441
2027
|
if (output.statusCode >= 300) {
|
|
@@ -2462,43 +2048,22 @@ const deserializeAws_queryDetectStackSetDriftCommandError = async (output, conte
|
|
|
2462
2048
|
switch (errorCode) {
|
|
2463
2049
|
case "InvalidOperationException":
|
|
2464
2050
|
case "com.amazonaws.cloudformation#InvalidOperationException":
|
|
2465
|
-
|
|
2466
|
-
...(await deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)),
|
|
2467
|
-
name: errorCode,
|
|
2468
|
-
$metadata: deserializeMetadata(output),
|
|
2469
|
-
};
|
|
2470
|
-
break;
|
|
2051
|
+
throw await deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context);
|
|
2471
2052
|
case "OperationInProgressException":
|
|
2472
2053
|
case "com.amazonaws.cloudformation#OperationInProgressException":
|
|
2473
|
-
|
|
2474
|
-
...(await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)),
|
|
2475
|
-
name: errorCode,
|
|
2476
|
-
$metadata: deserializeMetadata(output),
|
|
2477
|
-
};
|
|
2478
|
-
break;
|
|
2054
|
+
throw await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context);
|
|
2479
2055
|
case "StackSetNotFoundException":
|
|
2480
2056
|
case "com.amazonaws.cloudformation#StackSetNotFoundException":
|
|
2481
|
-
|
|
2482
|
-
...(await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
2483
|
-
name: errorCode,
|
|
2484
|
-
$metadata: deserializeMetadata(output),
|
|
2485
|
-
};
|
|
2486
|
-
break;
|
|
2057
|
+
throw await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context);
|
|
2487
2058
|
default:
|
|
2488
2059
|
const parsedBody = parsedOutput.body;
|
|
2489
|
-
|
|
2490
|
-
|
|
2491
|
-
...parsedBody.Error,
|
|
2492
|
-
name: `${errorCode}`,
|
|
2493
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2060
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2061
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2494
2062
|
$fault: "client",
|
|
2495
2063
|
$metadata: deserializeMetadata(output),
|
|
2496
|
-
};
|
|
2064
|
+
});
|
|
2065
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2497
2066
|
}
|
|
2498
|
-
const message = response.message || response.Message || errorCode;
|
|
2499
|
-
response.message = message;
|
|
2500
|
-
delete response.Message;
|
|
2501
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2502
2067
|
};
|
|
2503
2068
|
const deserializeAws_queryEstimateTemplateCostCommand = async (output, context) => {
|
|
2504
2069
|
if (output.statusCode >= 300) {
|
|
@@ -2525,19 +2090,13 @@ const deserializeAws_queryEstimateTemplateCostCommandError = async (output, cont
|
|
|
2525
2090
|
switch (errorCode) {
|
|
2526
2091
|
default:
|
|
2527
2092
|
const parsedBody = parsedOutput.body;
|
|
2528
|
-
|
|
2529
|
-
|
|
2530
|
-
...parsedBody.Error,
|
|
2531
|
-
name: `${errorCode}`,
|
|
2532
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2093
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2094
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2533
2095
|
$fault: "client",
|
|
2534
2096
|
$metadata: deserializeMetadata(output),
|
|
2535
|
-
};
|
|
2097
|
+
});
|
|
2098
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2536
2099
|
}
|
|
2537
|
-
const message = response.message || response.Message || errorCode;
|
|
2538
|
-
response.message = message;
|
|
2539
|
-
delete response.Message;
|
|
2540
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2541
2100
|
};
|
|
2542
2101
|
const deserializeAws_queryExecuteChangeSetCommand = async (output, context) => {
|
|
2543
2102
|
if (output.statusCode >= 300) {
|
|
@@ -2564,51 +2123,25 @@ const deserializeAws_queryExecuteChangeSetCommandError = async (output, context)
|
|
|
2564
2123
|
switch (errorCode) {
|
|
2565
2124
|
case "ChangeSetNotFoundException":
|
|
2566
2125
|
case "com.amazonaws.cloudformation#ChangeSetNotFoundException":
|
|
2567
|
-
|
|
2568
|
-
...(await deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
2569
|
-
name: errorCode,
|
|
2570
|
-
$metadata: deserializeMetadata(output),
|
|
2571
|
-
};
|
|
2572
|
-
break;
|
|
2126
|
+
throw await deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context);
|
|
2573
2127
|
case "InsufficientCapabilitiesException":
|
|
2574
2128
|
case "com.amazonaws.cloudformation#InsufficientCapabilitiesException":
|
|
2575
|
-
|
|
2576
|
-
...(await deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context)),
|
|
2577
|
-
name: errorCode,
|
|
2578
|
-
$metadata: deserializeMetadata(output),
|
|
2579
|
-
};
|
|
2580
|
-
break;
|
|
2129
|
+
throw await deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context);
|
|
2581
2130
|
case "InvalidChangeSetStatusException":
|
|
2582
2131
|
case "com.amazonaws.cloudformation#InvalidChangeSetStatusException":
|
|
2583
|
-
|
|
2584
|
-
...(await deserializeAws_queryInvalidChangeSetStatusExceptionResponse(parsedOutput, context)),
|
|
2585
|
-
name: errorCode,
|
|
2586
|
-
$metadata: deserializeMetadata(output),
|
|
2587
|
-
};
|
|
2588
|
-
break;
|
|
2132
|
+
throw await deserializeAws_queryInvalidChangeSetStatusExceptionResponse(parsedOutput, context);
|
|
2589
2133
|
case "TokenAlreadyExistsException":
|
|
2590
2134
|
case "com.amazonaws.cloudformation#TokenAlreadyExistsException":
|
|
2591
|
-
|
|
2592
|
-
...(await deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)),
|
|
2593
|
-
name: errorCode,
|
|
2594
|
-
$metadata: deserializeMetadata(output),
|
|
2595
|
-
};
|
|
2596
|
-
break;
|
|
2135
|
+
throw await deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context);
|
|
2597
2136
|
default:
|
|
2598
2137
|
const parsedBody = parsedOutput.body;
|
|
2599
|
-
|
|
2600
|
-
|
|
2601
|
-
...parsedBody.Error,
|
|
2602
|
-
name: `${errorCode}`,
|
|
2603
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2138
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2139
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2604
2140
|
$fault: "client",
|
|
2605
2141
|
$metadata: deserializeMetadata(output),
|
|
2606
|
-
};
|
|
2142
|
+
});
|
|
2143
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2607
2144
|
}
|
|
2608
|
-
const message = response.message || response.Message || errorCode;
|
|
2609
|
-
response.message = message;
|
|
2610
|
-
delete response.Message;
|
|
2611
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2612
2145
|
};
|
|
2613
2146
|
const deserializeAws_queryGetStackPolicyCommand = async (output, context) => {
|
|
2614
2147
|
if (output.statusCode >= 300) {
|
|
@@ -2635,19 +2168,13 @@ const deserializeAws_queryGetStackPolicyCommandError = async (output, context) =
|
|
|
2635
2168
|
switch (errorCode) {
|
|
2636
2169
|
default:
|
|
2637
2170
|
const parsedBody = parsedOutput.body;
|
|
2638
|
-
|
|
2639
|
-
|
|
2640
|
-
...parsedBody.Error,
|
|
2641
|
-
name: `${errorCode}`,
|
|
2642
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2171
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2172
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2643
2173
|
$fault: "client",
|
|
2644
2174
|
$metadata: deserializeMetadata(output),
|
|
2645
|
-
};
|
|
2175
|
+
});
|
|
2176
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2646
2177
|
}
|
|
2647
|
-
const message = response.message || response.Message || errorCode;
|
|
2648
|
-
response.message = message;
|
|
2649
|
-
delete response.Message;
|
|
2650
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2651
2178
|
};
|
|
2652
2179
|
const deserializeAws_queryGetTemplateCommand = async (output, context) => {
|
|
2653
2180
|
if (output.statusCode >= 300) {
|
|
@@ -2674,27 +2201,16 @@ const deserializeAws_queryGetTemplateCommandError = async (output, context) => {
|
|
|
2674
2201
|
switch (errorCode) {
|
|
2675
2202
|
case "ChangeSetNotFoundException":
|
|
2676
2203
|
case "com.amazonaws.cloudformation#ChangeSetNotFoundException":
|
|
2677
|
-
|
|
2678
|
-
...(await deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
2679
|
-
name: errorCode,
|
|
2680
|
-
$metadata: deserializeMetadata(output),
|
|
2681
|
-
};
|
|
2682
|
-
break;
|
|
2204
|
+
throw await deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context);
|
|
2683
2205
|
default:
|
|
2684
2206
|
const parsedBody = parsedOutput.body;
|
|
2685
|
-
|
|
2686
|
-
|
|
2687
|
-
...parsedBody.Error,
|
|
2688
|
-
name: `${errorCode}`,
|
|
2689
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2207
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2208
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2690
2209
|
$fault: "client",
|
|
2691
2210
|
$metadata: deserializeMetadata(output),
|
|
2692
|
-
};
|
|
2211
|
+
});
|
|
2212
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2693
2213
|
}
|
|
2694
|
-
const message = response.message || response.Message || errorCode;
|
|
2695
|
-
response.message = message;
|
|
2696
|
-
delete response.Message;
|
|
2697
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2698
2214
|
};
|
|
2699
2215
|
const deserializeAws_queryGetTemplateSummaryCommand = async (output, context) => {
|
|
2700
2216
|
if (output.statusCode >= 300) {
|
|
@@ -2721,27 +2237,16 @@ const deserializeAws_queryGetTemplateSummaryCommandError = async (output, contex
|
|
|
2721
2237
|
switch (errorCode) {
|
|
2722
2238
|
case "StackSetNotFoundException":
|
|
2723
2239
|
case "com.amazonaws.cloudformation#StackSetNotFoundException":
|
|
2724
|
-
|
|
2725
|
-
...(await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
2726
|
-
name: errorCode,
|
|
2727
|
-
$metadata: deserializeMetadata(output),
|
|
2728
|
-
};
|
|
2729
|
-
break;
|
|
2240
|
+
throw await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context);
|
|
2730
2241
|
default:
|
|
2731
2242
|
const parsedBody = parsedOutput.body;
|
|
2732
|
-
|
|
2733
|
-
|
|
2734
|
-
...parsedBody.Error,
|
|
2735
|
-
name: `${errorCode}`,
|
|
2736
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2243
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2244
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2737
2245
|
$fault: "client",
|
|
2738
2246
|
$metadata: deserializeMetadata(output),
|
|
2739
|
-
};
|
|
2247
|
+
});
|
|
2248
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2740
2249
|
}
|
|
2741
|
-
const message = response.message || response.Message || errorCode;
|
|
2742
|
-
response.message = message;
|
|
2743
|
-
delete response.Message;
|
|
2744
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2745
2250
|
};
|
|
2746
2251
|
const deserializeAws_queryImportStacksToStackSetCommand = async (output, context) => {
|
|
2747
2252
|
if (output.statusCode >= 300) {
|
|
@@ -2768,75 +2273,34 @@ const deserializeAws_queryImportStacksToStackSetCommandError = async (output, co
|
|
|
2768
2273
|
switch (errorCode) {
|
|
2769
2274
|
case "InvalidOperationException":
|
|
2770
2275
|
case "com.amazonaws.cloudformation#InvalidOperationException":
|
|
2771
|
-
|
|
2772
|
-
...(await deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)),
|
|
2773
|
-
name: errorCode,
|
|
2774
|
-
$metadata: deserializeMetadata(output),
|
|
2775
|
-
};
|
|
2776
|
-
break;
|
|
2276
|
+
throw await deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context);
|
|
2777
2277
|
case "LimitExceededException":
|
|
2778
2278
|
case "com.amazonaws.cloudformation#LimitExceededException":
|
|
2779
|
-
|
|
2780
|
-
...(await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context)),
|
|
2781
|
-
name: errorCode,
|
|
2782
|
-
$metadata: deserializeMetadata(output),
|
|
2783
|
-
};
|
|
2784
|
-
break;
|
|
2279
|
+
throw await deserializeAws_queryLimitExceededExceptionResponse(parsedOutput, context);
|
|
2785
2280
|
case "OperationIdAlreadyExistsException":
|
|
2786
2281
|
case "com.amazonaws.cloudformation#OperationIdAlreadyExistsException":
|
|
2787
|
-
|
|
2788
|
-
...(await deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context)),
|
|
2789
|
-
name: errorCode,
|
|
2790
|
-
$metadata: deserializeMetadata(output),
|
|
2791
|
-
};
|
|
2792
|
-
break;
|
|
2282
|
+
throw await deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context);
|
|
2793
2283
|
case "OperationInProgressException":
|
|
2794
2284
|
case "com.amazonaws.cloudformation#OperationInProgressException":
|
|
2795
|
-
|
|
2796
|
-
...(await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)),
|
|
2797
|
-
name: errorCode,
|
|
2798
|
-
$metadata: deserializeMetadata(output),
|
|
2799
|
-
};
|
|
2800
|
-
break;
|
|
2285
|
+
throw await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context);
|
|
2801
2286
|
case "StackNotFoundException":
|
|
2802
2287
|
case "com.amazonaws.cloudformation#StackNotFoundException":
|
|
2803
|
-
|
|
2804
|
-
...(await deserializeAws_queryStackNotFoundExceptionResponse(parsedOutput, context)),
|
|
2805
|
-
name: errorCode,
|
|
2806
|
-
$metadata: deserializeMetadata(output),
|
|
2807
|
-
};
|
|
2808
|
-
break;
|
|
2288
|
+
throw await deserializeAws_queryStackNotFoundExceptionResponse(parsedOutput, context);
|
|
2809
2289
|
case "StackSetNotFoundException":
|
|
2810
2290
|
case "com.amazonaws.cloudformation#StackSetNotFoundException":
|
|
2811
|
-
|
|
2812
|
-
...(await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
2813
|
-
name: errorCode,
|
|
2814
|
-
$metadata: deserializeMetadata(output),
|
|
2815
|
-
};
|
|
2816
|
-
break;
|
|
2291
|
+
throw await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context);
|
|
2817
2292
|
case "StaleRequestException":
|
|
2818
2293
|
case "com.amazonaws.cloudformation#StaleRequestException":
|
|
2819
|
-
|
|
2820
|
-
...(await deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context)),
|
|
2821
|
-
name: errorCode,
|
|
2822
|
-
$metadata: deserializeMetadata(output),
|
|
2823
|
-
};
|
|
2824
|
-
break;
|
|
2294
|
+
throw await deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context);
|
|
2825
2295
|
default:
|
|
2826
2296
|
const parsedBody = parsedOutput.body;
|
|
2827
|
-
|
|
2828
|
-
|
|
2829
|
-
...parsedBody.Error,
|
|
2830
|
-
name: `${errorCode}`,
|
|
2831
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2297
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2298
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2832
2299
|
$fault: "client",
|
|
2833
2300
|
$metadata: deserializeMetadata(output),
|
|
2834
|
-
};
|
|
2301
|
+
});
|
|
2302
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2835
2303
|
}
|
|
2836
|
-
const message = response.message || response.Message || errorCode;
|
|
2837
|
-
response.message = message;
|
|
2838
|
-
delete response.Message;
|
|
2839
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2840
2304
|
};
|
|
2841
2305
|
const deserializeAws_queryListChangeSetsCommand = async (output, context) => {
|
|
2842
2306
|
if (output.statusCode >= 300) {
|
|
@@ -2863,19 +2327,13 @@ const deserializeAws_queryListChangeSetsCommandError = async (output, context) =
|
|
|
2863
2327
|
switch (errorCode) {
|
|
2864
2328
|
default:
|
|
2865
2329
|
const parsedBody = parsedOutput.body;
|
|
2866
|
-
|
|
2867
|
-
|
|
2868
|
-
...parsedBody.Error,
|
|
2869
|
-
name: `${errorCode}`,
|
|
2870
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2330
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2331
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2871
2332
|
$fault: "client",
|
|
2872
2333
|
$metadata: deserializeMetadata(output),
|
|
2873
|
-
};
|
|
2334
|
+
});
|
|
2335
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2874
2336
|
}
|
|
2875
|
-
const message = response.message || response.Message || errorCode;
|
|
2876
|
-
response.message = message;
|
|
2877
|
-
delete response.Message;
|
|
2878
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2879
2337
|
};
|
|
2880
2338
|
const deserializeAws_queryListExportsCommand = async (output, context) => {
|
|
2881
2339
|
if (output.statusCode >= 300) {
|
|
@@ -2902,19 +2360,13 @@ const deserializeAws_queryListExportsCommandError = async (output, context) => {
|
|
|
2902
2360
|
switch (errorCode) {
|
|
2903
2361
|
default:
|
|
2904
2362
|
const parsedBody = parsedOutput.body;
|
|
2905
|
-
|
|
2906
|
-
|
|
2907
|
-
...parsedBody.Error,
|
|
2908
|
-
name: `${errorCode}`,
|
|
2909
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2363
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2364
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2910
2365
|
$fault: "client",
|
|
2911
2366
|
$metadata: deserializeMetadata(output),
|
|
2912
|
-
};
|
|
2367
|
+
});
|
|
2368
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2913
2369
|
}
|
|
2914
|
-
const message = response.message || response.Message || errorCode;
|
|
2915
|
-
response.message = message;
|
|
2916
|
-
delete response.Message;
|
|
2917
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2918
2370
|
};
|
|
2919
2371
|
const deserializeAws_queryListImportsCommand = async (output, context) => {
|
|
2920
2372
|
if (output.statusCode >= 300) {
|
|
@@ -2941,19 +2393,13 @@ const deserializeAws_queryListImportsCommandError = async (output, context) => {
|
|
|
2941
2393
|
switch (errorCode) {
|
|
2942
2394
|
default:
|
|
2943
2395
|
const parsedBody = parsedOutput.body;
|
|
2944
|
-
|
|
2945
|
-
|
|
2946
|
-
...parsedBody.Error,
|
|
2947
|
-
name: `${errorCode}`,
|
|
2948
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2396
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2397
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2949
2398
|
$fault: "client",
|
|
2950
2399
|
$metadata: deserializeMetadata(output),
|
|
2951
|
-
};
|
|
2400
|
+
});
|
|
2401
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2952
2402
|
}
|
|
2953
|
-
const message = response.message || response.Message || errorCode;
|
|
2954
|
-
response.message = message;
|
|
2955
|
-
delete response.Message;
|
|
2956
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
2957
2403
|
};
|
|
2958
2404
|
const deserializeAws_queryListStackInstancesCommand = async (output, context) => {
|
|
2959
2405
|
if (output.statusCode >= 300) {
|
|
@@ -2980,27 +2426,16 @@ const deserializeAws_queryListStackInstancesCommandError = async (output, contex
|
|
|
2980
2426
|
switch (errorCode) {
|
|
2981
2427
|
case "StackSetNotFoundException":
|
|
2982
2428
|
case "com.amazonaws.cloudformation#StackSetNotFoundException":
|
|
2983
|
-
|
|
2984
|
-
...(await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
2985
|
-
name: errorCode,
|
|
2986
|
-
$metadata: deserializeMetadata(output),
|
|
2987
|
-
};
|
|
2988
|
-
break;
|
|
2429
|
+
throw await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context);
|
|
2989
2430
|
default:
|
|
2990
2431
|
const parsedBody = parsedOutput.body;
|
|
2991
|
-
|
|
2992
|
-
|
|
2993
|
-
...parsedBody.Error,
|
|
2994
|
-
name: `${errorCode}`,
|
|
2995
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2432
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2433
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
2996
2434
|
$fault: "client",
|
|
2997
2435
|
$metadata: deserializeMetadata(output),
|
|
2998
|
-
};
|
|
2436
|
+
});
|
|
2437
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
2999
2438
|
}
|
|
3000
|
-
const message = response.message || response.Message || errorCode;
|
|
3001
|
-
response.message = message;
|
|
3002
|
-
delete response.Message;
|
|
3003
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3004
2439
|
};
|
|
3005
2440
|
const deserializeAws_queryListStackResourcesCommand = async (output, context) => {
|
|
3006
2441
|
if (output.statusCode >= 300) {
|
|
@@ -3027,19 +2462,13 @@ const deserializeAws_queryListStackResourcesCommandError = async (output, contex
|
|
|
3027
2462
|
switch (errorCode) {
|
|
3028
2463
|
default:
|
|
3029
2464
|
const parsedBody = parsedOutput.body;
|
|
3030
|
-
|
|
3031
|
-
|
|
3032
|
-
...parsedBody.Error,
|
|
3033
|
-
name: `${errorCode}`,
|
|
3034
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2465
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2466
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3035
2467
|
$fault: "client",
|
|
3036
2468
|
$metadata: deserializeMetadata(output),
|
|
3037
|
-
};
|
|
2469
|
+
});
|
|
2470
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3038
2471
|
}
|
|
3039
|
-
const message = response.message || response.Message || errorCode;
|
|
3040
|
-
response.message = message;
|
|
3041
|
-
delete response.Message;
|
|
3042
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3043
2472
|
};
|
|
3044
2473
|
const deserializeAws_queryListStacksCommand = async (output, context) => {
|
|
3045
2474
|
if (output.statusCode >= 300) {
|
|
@@ -3066,19 +2495,13 @@ const deserializeAws_queryListStacksCommandError = async (output, context) => {
|
|
|
3066
2495
|
switch (errorCode) {
|
|
3067
2496
|
default:
|
|
3068
2497
|
const parsedBody = parsedOutput.body;
|
|
3069
|
-
|
|
3070
|
-
|
|
3071
|
-
...parsedBody.Error,
|
|
3072
|
-
name: `${errorCode}`,
|
|
3073
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2498
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2499
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3074
2500
|
$fault: "client",
|
|
3075
2501
|
$metadata: deserializeMetadata(output),
|
|
3076
|
-
};
|
|
2502
|
+
});
|
|
2503
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3077
2504
|
}
|
|
3078
|
-
const message = response.message || response.Message || errorCode;
|
|
3079
|
-
response.message = message;
|
|
3080
|
-
delete response.Message;
|
|
3081
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3082
2505
|
};
|
|
3083
2506
|
const deserializeAws_queryListStackSetOperationResultsCommand = async (output, context) => {
|
|
3084
2507
|
if (output.statusCode >= 300) {
|
|
@@ -3105,35 +2528,19 @@ const deserializeAws_queryListStackSetOperationResultsCommandError = async (outp
|
|
|
3105
2528
|
switch (errorCode) {
|
|
3106
2529
|
case "OperationNotFoundException":
|
|
3107
2530
|
case "com.amazonaws.cloudformation#OperationNotFoundException":
|
|
3108
|
-
|
|
3109
|
-
...(await deserializeAws_queryOperationNotFoundExceptionResponse(parsedOutput, context)),
|
|
3110
|
-
name: errorCode,
|
|
3111
|
-
$metadata: deserializeMetadata(output),
|
|
3112
|
-
};
|
|
3113
|
-
break;
|
|
2531
|
+
throw await deserializeAws_queryOperationNotFoundExceptionResponse(parsedOutput, context);
|
|
3114
2532
|
case "StackSetNotFoundException":
|
|
3115
2533
|
case "com.amazonaws.cloudformation#StackSetNotFoundException":
|
|
3116
|
-
|
|
3117
|
-
...(await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
3118
|
-
name: errorCode,
|
|
3119
|
-
$metadata: deserializeMetadata(output),
|
|
3120
|
-
};
|
|
3121
|
-
break;
|
|
2534
|
+
throw await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context);
|
|
3122
2535
|
default:
|
|
3123
2536
|
const parsedBody = parsedOutput.body;
|
|
3124
|
-
|
|
3125
|
-
|
|
3126
|
-
...parsedBody.Error,
|
|
3127
|
-
name: `${errorCode}`,
|
|
3128
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2537
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2538
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3129
2539
|
$fault: "client",
|
|
3130
2540
|
$metadata: deserializeMetadata(output),
|
|
3131
|
-
};
|
|
2541
|
+
});
|
|
2542
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3132
2543
|
}
|
|
3133
|
-
const message = response.message || response.Message || errorCode;
|
|
3134
|
-
response.message = message;
|
|
3135
|
-
delete response.Message;
|
|
3136
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3137
2544
|
};
|
|
3138
2545
|
const deserializeAws_queryListStackSetOperationsCommand = async (output, context) => {
|
|
3139
2546
|
if (output.statusCode >= 300) {
|
|
@@ -3160,27 +2567,16 @@ const deserializeAws_queryListStackSetOperationsCommandError = async (output, co
|
|
|
3160
2567
|
switch (errorCode) {
|
|
3161
2568
|
case "StackSetNotFoundException":
|
|
3162
2569
|
case "com.amazonaws.cloudformation#StackSetNotFoundException":
|
|
3163
|
-
|
|
3164
|
-
...(await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
3165
|
-
name: errorCode,
|
|
3166
|
-
$metadata: deserializeMetadata(output),
|
|
3167
|
-
};
|
|
3168
|
-
break;
|
|
2570
|
+
throw await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context);
|
|
3169
2571
|
default:
|
|
3170
2572
|
const parsedBody = parsedOutput.body;
|
|
3171
|
-
|
|
3172
|
-
|
|
3173
|
-
...parsedBody.Error,
|
|
3174
|
-
name: `${errorCode}`,
|
|
3175
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2573
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2574
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3176
2575
|
$fault: "client",
|
|
3177
2576
|
$metadata: deserializeMetadata(output),
|
|
3178
|
-
};
|
|
2577
|
+
});
|
|
2578
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3179
2579
|
}
|
|
3180
|
-
const message = response.message || response.Message || errorCode;
|
|
3181
|
-
response.message = message;
|
|
3182
|
-
delete response.Message;
|
|
3183
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3184
2580
|
};
|
|
3185
2581
|
const deserializeAws_queryListStackSetsCommand = async (output, context) => {
|
|
3186
2582
|
if (output.statusCode >= 300) {
|
|
@@ -3207,19 +2603,13 @@ const deserializeAws_queryListStackSetsCommandError = async (output, context) =>
|
|
|
3207
2603
|
switch (errorCode) {
|
|
3208
2604
|
default:
|
|
3209
2605
|
const parsedBody = parsedOutput.body;
|
|
3210
|
-
|
|
3211
|
-
|
|
3212
|
-
...parsedBody.Error,
|
|
3213
|
-
name: `${errorCode}`,
|
|
3214
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2606
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2607
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3215
2608
|
$fault: "client",
|
|
3216
2609
|
$metadata: deserializeMetadata(output),
|
|
3217
|
-
};
|
|
2610
|
+
});
|
|
2611
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3218
2612
|
}
|
|
3219
|
-
const message = response.message || response.Message || errorCode;
|
|
3220
|
-
response.message = message;
|
|
3221
|
-
delete response.Message;
|
|
3222
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3223
2613
|
};
|
|
3224
2614
|
const deserializeAws_queryListTypeRegistrationsCommand = async (output, context) => {
|
|
3225
2615
|
if (output.statusCode >= 300) {
|
|
@@ -3246,27 +2636,16 @@ const deserializeAws_queryListTypeRegistrationsCommandError = async (output, con
|
|
|
3246
2636
|
switch (errorCode) {
|
|
3247
2637
|
case "CFNRegistryException":
|
|
3248
2638
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
3249
|
-
|
|
3250
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
3251
|
-
name: errorCode,
|
|
3252
|
-
$metadata: deserializeMetadata(output),
|
|
3253
|
-
};
|
|
3254
|
-
break;
|
|
2639
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
3255
2640
|
default:
|
|
3256
2641
|
const parsedBody = parsedOutput.body;
|
|
3257
|
-
|
|
3258
|
-
|
|
3259
|
-
...parsedBody.Error,
|
|
3260
|
-
name: `${errorCode}`,
|
|
3261
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2642
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2643
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3262
2644
|
$fault: "client",
|
|
3263
2645
|
$metadata: deserializeMetadata(output),
|
|
3264
|
-
};
|
|
2646
|
+
});
|
|
2647
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3265
2648
|
}
|
|
3266
|
-
const message = response.message || response.Message || errorCode;
|
|
3267
|
-
response.message = message;
|
|
3268
|
-
delete response.Message;
|
|
3269
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3270
2649
|
};
|
|
3271
2650
|
const deserializeAws_queryListTypesCommand = async (output, context) => {
|
|
3272
2651
|
if (output.statusCode >= 300) {
|
|
@@ -3293,27 +2672,16 @@ const deserializeAws_queryListTypesCommandError = async (output, context) => {
|
|
|
3293
2672
|
switch (errorCode) {
|
|
3294
2673
|
case "CFNRegistryException":
|
|
3295
2674
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
3296
|
-
|
|
3297
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
3298
|
-
name: errorCode,
|
|
3299
|
-
$metadata: deserializeMetadata(output),
|
|
3300
|
-
};
|
|
3301
|
-
break;
|
|
2675
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
3302
2676
|
default:
|
|
3303
2677
|
const parsedBody = parsedOutput.body;
|
|
3304
|
-
|
|
3305
|
-
|
|
3306
|
-
...parsedBody.Error,
|
|
3307
|
-
name: `${errorCode}`,
|
|
3308
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2678
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2679
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3309
2680
|
$fault: "client",
|
|
3310
2681
|
$metadata: deserializeMetadata(output),
|
|
3311
|
-
};
|
|
2682
|
+
});
|
|
2683
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3312
2684
|
}
|
|
3313
|
-
const message = response.message || response.Message || errorCode;
|
|
3314
|
-
response.message = message;
|
|
3315
|
-
delete response.Message;
|
|
3316
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3317
2685
|
};
|
|
3318
2686
|
const deserializeAws_queryListTypeVersionsCommand = async (output, context) => {
|
|
3319
2687
|
if (output.statusCode >= 300) {
|
|
@@ -3340,27 +2708,16 @@ const deserializeAws_queryListTypeVersionsCommandError = async (output, context)
|
|
|
3340
2708
|
switch (errorCode) {
|
|
3341
2709
|
case "CFNRegistryException":
|
|
3342
2710
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
3343
|
-
|
|
3344
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
3345
|
-
name: errorCode,
|
|
3346
|
-
$metadata: deserializeMetadata(output),
|
|
3347
|
-
};
|
|
3348
|
-
break;
|
|
2711
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
3349
2712
|
default:
|
|
3350
2713
|
const parsedBody = parsedOutput.body;
|
|
3351
|
-
|
|
3352
|
-
|
|
3353
|
-
...parsedBody.Error,
|
|
3354
|
-
name: `${errorCode}`,
|
|
3355
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2714
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2715
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3356
2716
|
$fault: "client",
|
|
3357
2717
|
$metadata: deserializeMetadata(output),
|
|
3358
|
-
};
|
|
2718
|
+
});
|
|
2719
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3359
2720
|
}
|
|
3360
|
-
const message = response.message || response.Message || errorCode;
|
|
3361
|
-
response.message = message;
|
|
3362
|
-
delete response.Message;
|
|
3363
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3364
2721
|
};
|
|
3365
2722
|
const deserializeAws_queryPublishTypeCommand = async (output, context) => {
|
|
3366
2723
|
if (output.statusCode >= 300) {
|
|
@@ -3387,35 +2744,19 @@ const deserializeAws_queryPublishTypeCommandError = async (output, context) => {
|
|
|
3387
2744
|
switch (errorCode) {
|
|
3388
2745
|
case "CFNRegistryException":
|
|
3389
2746
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
3390
|
-
|
|
3391
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
3392
|
-
name: errorCode,
|
|
3393
|
-
$metadata: deserializeMetadata(output),
|
|
3394
|
-
};
|
|
3395
|
-
break;
|
|
2747
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
3396
2748
|
case "TypeNotFoundException":
|
|
3397
2749
|
case "com.amazonaws.cloudformation#TypeNotFoundException":
|
|
3398
|
-
|
|
3399
|
-
...(await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)),
|
|
3400
|
-
name: errorCode,
|
|
3401
|
-
$metadata: deserializeMetadata(output),
|
|
3402
|
-
};
|
|
3403
|
-
break;
|
|
2750
|
+
throw await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context);
|
|
3404
2751
|
default:
|
|
3405
2752
|
const parsedBody = parsedOutput.body;
|
|
3406
|
-
|
|
3407
|
-
|
|
3408
|
-
...parsedBody.Error,
|
|
3409
|
-
name: `${errorCode}`,
|
|
3410
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2753
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2754
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3411
2755
|
$fault: "client",
|
|
3412
2756
|
$metadata: deserializeMetadata(output),
|
|
3413
|
-
};
|
|
2757
|
+
});
|
|
2758
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3414
2759
|
}
|
|
3415
|
-
const message = response.message || response.Message || errorCode;
|
|
3416
|
-
response.message = message;
|
|
3417
|
-
delete response.Message;
|
|
3418
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3419
2760
|
};
|
|
3420
2761
|
const deserializeAws_queryRecordHandlerProgressCommand = async (output, context) => {
|
|
3421
2762
|
if (output.statusCode >= 300) {
|
|
@@ -3442,35 +2783,19 @@ const deserializeAws_queryRecordHandlerProgressCommandError = async (output, con
|
|
|
3442
2783
|
switch (errorCode) {
|
|
3443
2784
|
case "InvalidStateTransitionException":
|
|
3444
2785
|
case "com.amazonaws.cloudformation#InvalidStateTransitionException":
|
|
3445
|
-
|
|
3446
|
-
...(await deserializeAws_queryInvalidStateTransitionExceptionResponse(parsedOutput, context)),
|
|
3447
|
-
name: errorCode,
|
|
3448
|
-
$metadata: deserializeMetadata(output),
|
|
3449
|
-
};
|
|
3450
|
-
break;
|
|
2786
|
+
throw await deserializeAws_queryInvalidStateTransitionExceptionResponse(parsedOutput, context);
|
|
3451
2787
|
case "OperationStatusCheckFailedException":
|
|
3452
2788
|
case "com.amazonaws.cloudformation#OperationStatusCheckFailedException":
|
|
3453
|
-
|
|
3454
|
-
...(await deserializeAws_queryOperationStatusCheckFailedExceptionResponse(parsedOutput, context)),
|
|
3455
|
-
name: errorCode,
|
|
3456
|
-
$metadata: deserializeMetadata(output),
|
|
3457
|
-
};
|
|
3458
|
-
break;
|
|
2789
|
+
throw await deserializeAws_queryOperationStatusCheckFailedExceptionResponse(parsedOutput, context);
|
|
3459
2790
|
default:
|
|
3460
2791
|
const parsedBody = parsedOutput.body;
|
|
3461
|
-
|
|
3462
|
-
|
|
3463
|
-
...parsedBody.Error,
|
|
3464
|
-
name: `${errorCode}`,
|
|
3465
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2792
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2793
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3466
2794
|
$fault: "client",
|
|
3467
2795
|
$metadata: deserializeMetadata(output),
|
|
3468
|
-
};
|
|
2796
|
+
});
|
|
2797
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3469
2798
|
}
|
|
3470
|
-
const message = response.message || response.Message || errorCode;
|
|
3471
|
-
response.message = message;
|
|
3472
|
-
delete response.Message;
|
|
3473
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3474
2799
|
};
|
|
3475
2800
|
const deserializeAws_queryRegisterPublisherCommand = async (output, context) => {
|
|
3476
2801
|
if (output.statusCode >= 300) {
|
|
@@ -3497,27 +2822,16 @@ const deserializeAws_queryRegisterPublisherCommandError = async (output, context
|
|
|
3497
2822
|
switch (errorCode) {
|
|
3498
2823
|
case "CFNRegistryException":
|
|
3499
2824
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
3500
|
-
|
|
3501
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
3502
|
-
name: errorCode,
|
|
3503
|
-
$metadata: deserializeMetadata(output),
|
|
3504
|
-
};
|
|
3505
|
-
break;
|
|
2825
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
3506
2826
|
default:
|
|
3507
2827
|
const parsedBody = parsedOutput.body;
|
|
3508
|
-
|
|
3509
|
-
|
|
3510
|
-
...parsedBody.Error,
|
|
3511
|
-
name: `${errorCode}`,
|
|
3512
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2828
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2829
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3513
2830
|
$fault: "client",
|
|
3514
2831
|
$metadata: deserializeMetadata(output),
|
|
3515
|
-
};
|
|
2832
|
+
});
|
|
2833
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3516
2834
|
}
|
|
3517
|
-
const message = response.message || response.Message || errorCode;
|
|
3518
|
-
response.message = message;
|
|
3519
|
-
delete response.Message;
|
|
3520
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3521
2835
|
};
|
|
3522
2836
|
const deserializeAws_queryRegisterTypeCommand = async (output, context) => {
|
|
3523
2837
|
if (output.statusCode >= 300) {
|
|
@@ -3544,27 +2858,16 @@ const deserializeAws_queryRegisterTypeCommandError = async (output, context) =>
|
|
|
3544
2858
|
switch (errorCode) {
|
|
3545
2859
|
case "CFNRegistryException":
|
|
3546
2860
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
3547
|
-
|
|
3548
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
3549
|
-
name: errorCode,
|
|
3550
|
-
$metadata: deserializeMetadata(output),
|
|
3551
|
-
};
|
|
3552
|
-
break;
|
|
2861
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
3553
2862
|
default:
|
|
3554
2863
|
const parsedBody = parsedOutput.body;
|
|
3555
|
-
|
|
3556
|
-
|
|
3557
|
-
...parsedBody.Error,
|
|
3558
|
-
name: `${errorCode}`,
|
|
3559
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2864
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2865
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3560
2866
|
$fault: "client",
|
|
3561
2867
|
$metadata: deserializeMetadata(output),
|
|
3562
|
-
};
|
|
2868
|
+
});
|
|
2869
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3563
2870
|
}
|
|
3564
|
-
const message = response.message || response.Message || errorCode;
|
|
3565
|
-
response.message = message;
|
|
3566
|
-
delete response.Message;
|
|
3567
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3568
2871
|
};
|
|
3569
2872
|
const deserializeAws_queryRollbackStackCommand = async (output, context) => {
|
|
3570
2873
|
if (output.statusCode >= 300) {
|
|
@@ -3591,27 +2894,16 @@ const deserializeAws_queryRollbackStackCommandError = async (output, context) =>
|
|
|
3591
2894
|
switch (errorCode) {
|
|
3592
2895
|
case "TokenAlreadyExistsException":
|
|
3593
2896
|
case "com.amazonaws.cloudformation#TokenAlreadyExistsException":
|
|
3594
|
-
|
|
3595
|
-
...(await deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)),
|
|
3596
|
-
name: errorCode,
|
|
3597
|
-
$metadata: deserializeMetadata(output),
|
|
3598
|
-
};
|
|
3599
|
-
break;
|
|
2897
|
+
throw await deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context);
|
|
3600
2898
|
default:
|
|
3601
2899
|
const parsedBody = parsedOutput.body;
|
|
3602
|
-
|
|
3603
|
-
|
|
3604
|
-
...parsedBody.Error,
|
|
3605
|
-
name: `${errorCode}`,
|
|
3606
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2900
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2901
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3607
2902
|
$fault: "client",
|
|
3608
2903
|
$metadata: deserializeMetadata(output),
|
|
3609
|
-
};
|
|
2904
|
+
});
|
|
2905
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3610
2906
|
}
|
|
3611
|
-
const message = response.message || response.Message || errorCode;
|
|
3612
|
-
response.message = message;
|
|
3613
|
-
delete response.Message;
|
|
3614
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3615
2907
|
};
|
|
3616
2908
|
const deserializeAws_querySetStackPolicyCommand = async (output, context) => {
|
|
3617
2909
|
if (output.statusCode >= 300) {
|
|
@@ -3635,19 +2927,13 @@ const deserializeAws_querySetStackPolicyCommandError = async (output, context) =
|
|
|
3635
2927
|
switch (errorCode) {
|
|
3636
2928
|
default:
|
|
3637
2929
|
const parsedBody = parsedOutput.body;
|
|
3638
|
-
|
|
3639
|
-
|
|
3640
|
-
...parsedBody.Error,
|
|
3641
|
-
name: `${errorCode}`,
|
|
3642
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2930
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2931
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3643
2932
|
$fault: "client",
|
|
3644
2933
|
$metadata: deserializeMetadata(output),
|
|
3645
|
-
};
|
|
2934
|
+
});
|
|
2935
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3646
2936
|
}
|
|
3647
|
-
const message = response.message || response.Message || errorCode;
|
|
3648
|
-
response.message = message;
|
|
3649
|
-
delete response.Message;
|
|
3650
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3651
2937
|
};
|
|
3652
2938
|
const deserializeAws_querySetTypeConfigurationCommand = async (output, context) => {
|
|
3653
2939
|
if (output.statusCode >= 300) {
|
|
@@ -3674,35 +2960,19 @@ const deserializeAws_querySetTypeConfigurationCommandError = async (output, cont
|
|
|
3674
2960
|
switch (errorCode) {
|
|
3675
2961
|
case "CFNRegistryException":
|
|
3676
2962
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
3677
|
-
|
|
3678
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
3679
|
-
name: errorCode,
|
|
3680
|
-
$metadata: deserializeMetadata(output),
|
|
3681
|
-
};
|
|
3682
|
-
break;
|
|
2963
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
3683
2964
|
case "TypeNotFoundException":
|
|
3684
2965
|
case "com.amazonaws.cloudformation#TypeNotFoundException":
|
|
3685
|
-
|
|
3686
|
-
...(await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)),
|
|
3687
|
-
name: errorCode,
|
|
3688
|
-
$metadata: deserializeMetadata(output),
|
|
3689
|
-
};
|
|
3690
|
-
break;
|
|
2966
|
+
throw await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context);
|
|
3691
2967
|
default:
|
|
3692
2968
|
const parsedBody = parsedOutput.body;
|
|
3693
|
-
|
|
3694
|
-
|
|
3695
|
-
...parsedBody.Error,
|
|
3696
|
-
name: `${errorCode}`,
|
|
3697
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
2969
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
2970
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3698
2971
|
$fault: "client",
|
|
3699
2972
|
$metadata: deserializeMetadata(output),
|
|
3700
|
-
};
|
|
2973
|
+
});
|
|
2974
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3701
2975
|
}
|
|
3702
|
-
const message = response.message || response.Message || errorCode;
|
|
3703
|
-
response.message = message;
|
|
3704
|
-
delete response.Message;
|
|
3705
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3706
2976
|
};
|
|
3707
2977
|
const deserializeAws_querySetTypeDefaultVersionCommand = async (output, context) => {
|
|
3708
2978
|
if (output.statusCode >= 300) {
|
|
@@ -3729,35 +2999,19 @@ const deserializeAws_querySetTypeDefaultVersionCommandError = async (output, con
|
|
|
3729
2999
|
switch (errorCode) {
|
|
3730
3000
|
case "CFNRegistryException":
|
|
3731
3001
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
3732
|
-
|
|
3733
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
3734
|
-
name: errorCode,
|
|
3735
|
-
$metadata: deserializeMetadata(output),
|
|
3736
|
-
};
|
|
3737
|
-
break;
|
|
3002
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
3738
3003
|
case "TypeNotFoundException":
|
|
3739
3004
|
case "com.amazonaws.cloudformation#TypeNotFoundException":
|
|
3740
|
-
|
|
3741
|
-
...(await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)),
|
|
3742
|
-
name: errorCode,
|
|
3743
|
-
$metadata: deserializeMetadata(output),
|
|
3744
|
-
};
|
|
3745
|
-
break;
|
|
3005
|
+
throw await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context);
|
|
3746
3006
|
default:
|
|
3747
3007
|
const parsedBody = parsedOutput.body;
|
|
3748
|
-
|
|
3749
|
-
|
|
3750
|
-
...parsedBody.Error,
|
|
3751
|
-
name: `${errorCode}`,
|
|
3752
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
3008
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
3009
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3753
3010
|
$fault: "client",
|
|
3754
3011
|
$metadata: deserializeMetadata(output),
|
|
3755
|
-
};
|
|
3012
|
+
});
|
|
3013
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3756
3014
|
}
|
|
3757
|
-
const message = response.message || response.Message || errorCode;
|
|
3758
|
-
response.message = message;
|
|
3759
|
-
delete response.Message;
|
|
3760
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3761
3015
|
};
|
|
3762
3016
|
const deserializeAws_querySignalResourceCommand = async (output, context) => {
|
|
3763
3017
|
if (output.statusCode >= 300) {
|
|
@@ -3781,19 +3035,13 @@ const deserializeAws_querySignalResourceCommandError = async (output, context) =
|
|
|
3781
3035
|
switch (errorCode) {
|
|
3782
3036
|
default:
|
|
3783
3037
|
const parsedBody = parsedOutput.body;
|
|
3784
|
-
|
|
3785
|
-
|
|
3786
|
-
...parsedBody.Error,
|
|
3787
|
-
name: `${errorCode}`,
|
|
3788
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
3038
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
3039
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3789
3040
|
$fault: "client",
|
|
3790
3041
|
$metadata: deserializeMetadata(output),
|
|
3791
|
-
};
|
|
3042
|
+
});
|
|
3043
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3792
3044
|
}
|
|
3793
|
-
const message = response.message || response.Message || errorCode;
|
|
3794
|
-
response.message = message;
|
|
3795
|
-
delete response.Message;
|
|
3796
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3797
3045
|
};
|
|
3798
3046
|
const deserializeAws_queryStopStackSetOperationCommand = async (output, context) => {
|
|
3799
3047
|
if (output.statusCode >= 300) {
|
|
@@ -3820,43 +3068,22 @@ const deserializeAws_queryStopStackSetOperationCommandError = async (output, con
|
|
|
3820
3068
|
switch (errorCode) {
|
|
3821
3069
|
case "InvalidOperationException":
|
|
3822
3070
|
case "com.amazonaws.cloudformation#InvalidOperationException":
|
|
3823
|
-
|
|
3824
|
-
...(await deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)),
|
|
3825
|
-
name: errorCode,
|
|
3826
|
-
$metadata: deserializeMetadata(output),
|
|
3827
|
-
};
|
|
3828
|
-
break;
|
|
3071
|
+
throw await deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context);
|
|
3829
3072
|
case "OperationNotFoundException":
|
|
3830
3073
|
case "com.amazonaws.cloudformation#OperationNotFoundException":
|
|
3831
|
-
|
|
3832
|
-
...(await deserializeAws_queryOperationNotFoundExceptionResponse(parsedOutput, context)),
|
|
3833
|
-
name: errorCode,
|
|
3834
|
-
$metadata: deserializeMetadata(output),
|
|
3835
|
-
};
|
|
3836
|
-
break;
|
|
3074
|
+
throw await deserializeAws_queryOperationNotFoundExceptionResponse(parsedOutput, context);
|
|
3837
3075
|
case "StackSetNotFoundException":
|
|
3838
3076
|
case "com.amazonaws.cloudformation#StackSetNotFoundException":
|
|
3839
|
-
|
|
3840
|
-
...(await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
3841
|
-
name: errorCode,
|
|
3842
|
-
$metadata: deserializeMetadata(output),
|
|
3843
|
-
};
|
|
3844
|
-
break;
|
|
3077
|
+
throw await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context);
|
|
3845
3078
|
default:
|
|
3846
3079
|
const parsedBody = parsedOutput.body;
|
|
3847
|
-
|
|
3848
|
-
|
|
3849
|
-
...parsedBody.Error,
|
|
3850
|
-
name: `${errorCode}`,
|
|
3851
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
3080
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
3081
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3852
3082
|
$fault: "client",
|
|
3853
3083
|
$metadata: deserializeMetadata(output),
|
|
3854
|
-
};
|
|
3084
|
+
});
|
|
3085
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3855
3086
|
}
|
|
3856
|
-
const message = response.message || response.Message || errorCode;
|
|
3857
|
-
response.message = message;
|
|
3858
|
-
delete response.Message;
|
|
3859
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3860
3087
|
};
|
|
3861
3088
|
const deserializeAws_queryTestTypeCommand = async (output, context) => {
|
|
3862
3089
|
if (output.statusCode >= 300) {
|
|
@@ -3883,35 +3110,19 @@ const deserializeAws_queryTestTypeCommandError = async (output, context) => {
|
|
|
3883
3110
|
switch (errorCode) {
|
|
3884
3111
|
case "CFNRegistryException":
|
|
3885
3112
|
case "com.amazonaws.cloudformation#CFNRegistryException":
|
|
3886
|
-
|
|
3887
|
-
...(await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context)),
|
|
3888
|
-
name: errorCode,
|
|
3889
|
-
$metadata: deserializeMetadata(output),
|
|
3890
|
-
};
|
|
3891
|
-
break;
|
|
3113
|
+
throw await deserializeAws_queryCFNRegistryExceptionResponse(parsedOutput, context);
|
|
3892
3114
|
case "TypeNotFoundException":
|
|
3893
3115
|
case "com.amazonaws.cloudformation#TypeNotFoundException":
|
|
3894
|
-
|
|
3895
|
-
...(await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context)),
|
|
3896
|
-
name: errorCode,
|
|
3897
|
-
$metadata: deserializeMetadata(output),
|
|
3898
|
-
};
|
|
3899
|
-
break;
|
|
3116
|
+
throw await deserializeAws_queryTypeNotFoundExceptionResponse(parsedOutput, context);
|
|
3900
3117
|
default:
|
|
3901
3118
|
const parsedBody = parsedOutput.body;
|
|
3902
|
-
|
|
3903
|
-
|
|
3904
|
-
...parsedBody.Error,
|
|
3905
|
-
name: `${errorCode}`,
|
|
3906
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
3119
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
3120
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3907
3121
|
$fault: "client",
|
|
3908
3122
|
$metadata: deserializeMetadata(output),
|
|
3909
|
-
};
|
|
3123
|
+
});
|
|
3124
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3910
3125
|
}
|
|
3911
|
-
const message = response.message || response.Message || errorCode;
|
|
3912
|
-
response.message = message;
|
|
3913
|
-
delete response.Message;
|
|
3914
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3915
3126
|
};
|
|
3916
3127
|
const deserializeAws_queryUpdateStackCommand = async (output, context) => {
|
|
3917
3128
|
if (output.statusCode >= 300) {
|
|
@@ -3938,35 +3149,19 @@ const deserializeAws_queryUpdateStackCommandError = async (output, context) => {
|
|
|
3938
3149
|
switch (errorCode) {
|
|
3939
3150
|
case "InsufficientCapabilitiesException":
|
|
3940
3151
|
case "com.amazonaws.cloudformation#InsufficientCapabilitiesException":
|
|
3941
|
-
|
|
3942
|
-
...(await deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context)),
|
|
3943
|
-
name: errorCode,
|
|
3944
|
-
$metadata: deserializeMetadata(output),
|
|
3945
|
-
};
|
|
3946
|
-
break;
|
|
3152
|
+
throw await deserializeAws_queryInsufficientCapabilitiesExceptionResponse(parsedOutput, context);
|
|
3947
3153
|
case "TokenAlreadyExistsException":
|
|
3948
3154
|
case "com.amazonaws.cloudformation#TokenAlreadyExistsException":
|
|
3949
|
-
|
|
3950
|
-
...(await deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context)),
|
|
3951
|
-
name: errorCode,
|
|
3952
|
-
$metadata: deserializeMetadata(output),
|
|
3953
|
-
};
|
|
3954
|
-
break;
|
|
3155
|
+
throw await deserializeAws_queryTokenAlreadyExistsExceptionResponse(parsedOutput, context);
|
|
3955
3156
|
default:
|
|
3956
3157
|
const parsedBody = parsedOutput.body;
|
|
3957
|
-
|
|
3958
|
-
|
|
3959
|
-
...parsedBody.Error,
|
|
3960
|
-
name: `${errorCode}`,
|
|
3961
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
3158
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
3159
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
3962
3160
|
$fault: "client",
|
|
3963
3161
|
$metadata: deserializeMetadata(output),
|
|
3964
|
-
};
|
|
3162
|
+
});
|
|
3163
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
3965
3164
|
}
|
|
3966
|
-
const message = response.message || response.Message || errorCode;
|
|
3967
|
-
response.message = message;
|
|
3968
|
-
delete response.Message;
|
|
3969
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
3970
3165
|
};
|
|
3971
3166
|
const deserializeAws_queryUpdateStackInstancesCommand = async (output, context) => {
|
|
3972
3167
|
if (output.statusCode >= 300) {
|
|
@@ -3993,67 +3188,31 @@ const deserializeAws_queryUpdateStackInstancesCommandError = async (output, cont
|
|
|
3993
3188
|
switch (errorCode) {
|
|
3994
3189
|
case "InvalidOperationException":
|
|
3995
3190
|
case "com.amazonaws.cloudformation#InvalidOperationException":
|
|
3996
|
-
|
|
3997
|
-
...(await deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)),
|
|
3998
|
-
name: errorCode,
|
|
3999
|
-
$metadata: deserializeMetadata(output),
|
|
4000
|
-
};
|
|
4001
|
-
break;
|
|
3191
|
+
throw await deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context);
|
|
4002
3192
|
case "OperationIdAlreadyExistsException":
|
|
4003
3193
|
case "com.amazonaws.cloudformation#OperationIdAlreadyExistsException":
|
|
4004
|
-
|
|
4005
|
-
...(await deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context)),
|
|
4006
|
-
name: errorCode,
|
|
4007
|
-
$metadata: deserializeMetadata(output),
|
|
4008
|
-
};
|
|
4009
|
-
break;
|
|
3194
|
+
throw await deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context);
|
|
4010
3195
|
case "OperationInProgressException":
|
|
4011
3196
|
case "com.amazonaws.cloudformation#OperationInProgressException":
|
|
4012
|
-
|
|
4013
|
-
...(await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)),
|
|
4014
|
-
name: errorCode,
|
|
4015
|
-
$metadata: deserializeMetadata(output),
|
|
4016
|
-
};
|
|
4017
|
-
break;
|
|
3197
|
+
throw await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context);
|
|
4018
3198
|
case "StackInstanceNotFoundException":
|
|
4019
3199
|
case "com.amazonaws.cloudformation#StackInstanceNotFoundException":
|
|
4020
|
-
|
|
4021
|
-
...(await deserializeAws_queryStackInstanceNotFoundExceptionResponse(parsedOutput, context)),
|
|
4022
|
-
name: errorCode,
|
|
4023
|
-
$metadata: deserializeMetadata(output),
|
|
4024
|
-
};
|
|
4025
|
-
break;
|
|
3200
|
+
throw await deserializeAws_queryStackInstanceNotFoundExceptionResponse(parsedOutput, context);
|
|
4026
3201
|
case "StackSetNotFoundException":
|
|
4027
3202
|
case "com.amazonaws.cloudformation#StackSetNotFoundException":
|
|
4028
|
-
|
|
4029
|
-
...(await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
4030
|
-
name: errorCode,
|
|
4031
|
-
$metadata: deserializeMetadata(output),
|
|
4032
|
-
};
|
|
4033
|
-
break;
|
|
3203
|
+
throw await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context);
|
|
4034
3204
|
case "StaleRequestException":
|
|
4035
3205
|
case "com.amazonaws.cloudformation#StaleRequestException":
|
|
4036
|
-
|
|
4037
|
-
...(await deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context)),
|
|
4038
|
-
name: errorCode,
|
|
4039
|
-
$metadata: deserializeMetadata(output),
|
|
4040
|
-
};
|
|
4041
|
-
break;
|
|
3206
|
+
throw await deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context);
|
|
4042
3207
|
default:
|
|
4043
3208
|
const parsedBody = parsedOutput.body;
|
|
4044
|
-
|
|
4045
|
-
|
|
4046
|
-
...parsedBody.Error,
|
|
4047
|
-
name: `${errorCode}`,
|
|
4048
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
3209
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
3210
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
4049
3211
|
$fault: "client",
|
|
4050
3212
|
$metadata: deserializeMetadata(output),
|
|
4051
|
-
};
|
|
3213
|
+
});
|
|
3214
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
4052
3215
|
}
|
|
4053
|
-
const message = response.message || response.Message || errorCode;
|
|
4054
|
-
response.message = message;
|
|
4055
|
-
delete response.Message;
|
|
4056
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4057
3216
|
};
|
|
4058
3217
|
const deserializeAws_queryUpdateStackSetCommand = async (output, context) => {
|
|
4059
3218
|
if (output.statusCode >= 300) {
|
|
@@ -4080,67 +3239,31 @@ const deserializeAws_queryUpdateStackSetCommandError = async (output, context) =
|
|
|
4080
3239
|
switch (errorCode) {
|
|
4081
3240
|
case "InvalidOperationException":
|
|
4082
3241
|
case "com.amazonaws.cloudformation#InvalidOperationException":
|
|
4083
|
-
|
|
4084
|
-
...(await deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context)),
|
|
4085
|
-
name: errorCode,
|
|
4086
|
-
$metadata: deserializeMetadata(output),
|
|
4087
|
-
};
|
|
4088
|
-
break;
|
|
3242
|
+
throw await deserializeAws_queryInvalidOperationExceptionResponse(parsedOutput, context);
|
|
4089
3243
|
case "OperationIdAlreadyExistsException":
|
|
4090
3244
|
case "com.amazonaws.cloudformation#OperationIdAlreadyExistsException":
|
|
4091
|
-
|
|
4092
|
-
...(await deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context)),
|
|
4093
|
-
name: errorCode,
|
|
4094
|
-
$metadata: deserializeMetadata(output),
|
|
4095
|
-
};
|
|
4096
|
-
break;
|
|
3245
|
+
throw await deserializeAws_queryOperationIdAlreadyExistsExceptionResponse(parsedOutput, context);
|
|
4097
3246
|
case "OperationInProgressException":
|
|
4098
3247
|
case "com.amazonaws.cloudformation#OperationInProgressException":
|
|
4099
|
-
|
|
4100
|
-
...(await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context)),
|
|
4101
|
-
name: errorCode,
|
|
4102
|
-
$metadata: deserializeMetadata(output),
|
|
4103
|
-
};
|
|
4104
|
-
break;
|
|
3248
|
+
throw await deserializeAws_queryOperationInProgressExceptionResponse(parsedOutput, context);
|
|
4105
3249
|
case "StackInstanceNotFoundException":
|
|
4106
3250
|
case "com.amazonaws.cloudformation#StackInstanceNotFoundException":
|
|
4107
|
-
|
|
4108
|
-
...(await deserializeAws_queryStackInstanceNotFoundExceptionResponse(parsedOutput, context)),
|
|
4109
|
-
name: errorCode,
|
|
4110
|
-
$metadata: deserializeMetadata(output),
|
|
4111
|
-
};
|
|
4112
|
-
break;
|
|
3251
|
+
throw await deserializeAws_queryStackInstanceNotFoundExceptionResponse(parsedOutput, context);
|
|
4113
3252
|
case "StackSetNotFoundException":
|
|
4114
3253
|
case "com.amazonaws.cloudformation#StackSetNotFoundException":
|
|
4115
|
-
|
|
4116
|
-
...(await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context)),
|
|
4117
|
-
name: errorCode,
|
|
4118
|
-
$metadata: deserializeMetadata(output),
|
|
4119
|
-
};
|
|
4120
|
-
break;
|
|
3254
|
+
throw await deserializeAws_queryStackSetNotFoundExceptionResponse(parsedOutput, context);
|
|
4121
3255
|
case "StaleRequestException":
|
|
4122
3256
|
case "com.amazonaws.cloudformation#StaleRequestException":
|
|
4123
|
-
|
|
4124
|
-
...(await deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context)),
|
|
4125
|
-
name: errorCode,
|
|
4126
|
-
$metadata: deserializeMetadata(output),
|
|
4127
|
-
};
|
|
4128
|
-
break;
|
|
3257
|
+
throw await deserializeAws_queryStaleRequestExceptionResponse(parsedOutput, context);
|
|
4129
3258
|
default:
|
|
4130
3259
|
const parsedBody = parsedOutput.body;
|
|
4131
|
-
|
|
4132
|
-
|
|
4133
|
-
...parsedBody.Error,
|
|
4134
|
-
name: `${errorCode}`,
|
|
4135
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
3260
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
3261
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
4136
3262
|
$fault: "client",
|
|
4137
3263
|
$metadata: deserializeMetadata(output),
|
|
4138
|
-
};
|
|
3264
|
+
});
|
|
3265
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
4139
3266
|
}
|
|
4140
|
-
const message = response.message || response.Message || errorCode;
|
|
4141
|
-
response.message = message;
|
|
4142
|
-
delete response.Message;
|
|
4143
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4144
3267
|
};
|
|
4145
3268
|
const deserializeAws_queryUpdateTerminationProtectionCommand = async (output, context) => {
|
|
4146
3269
|
if (output.statusCode >= 300) {
|
|
@@ -4167,19 +3290,13 @@ const deserializeAws_queryUpdateTerminationProtectionCommandError = async (outpu
|
|
|
4167
3290
|
switch (errorCode) {
|
|
4168
3291
|
default:
|
|
4169
3292
|
const parsedBody = parsedOutput.body;
|
|
4170
|
-
|
|
4171
|
-
|
|
4172
|
-
...parsedBody.Error,
|
|
4173
|
-
name: `${errorCode}`,
|
|
4174
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
3293
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
3294
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
4175
3295
|
$fault: "client",
|
|
4176
3296
|
$metadata: deserializeMetadata(output),
|
|
4177
|
-
};
|
|
3297
|
+
});
|
|
3298
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
4178
3299
|
}
|
|
4179
|
-
const message = response.message || response.Message || errorCode;
|
|
4180
|
-
response.message = message;
|
|
4181
|
-
delete response.Message;
|
|
4182
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4183
3300
|
};
|
|
4184
3301
|
const deserializeAws_queryValidateTemplateCommand = async (output, context) => {
|
|
4185
3302
|
if (output.statusCode >= 300) {
|
|
@@ -4206,261 +3323,211 @@ const deserializeAws_queryValidateTemplateCommandError = async (output, context)
|
|
|
4206
3323
|
switch (errorCode) {
|
|
4207
3324
|
default:
|
|
4208
3325
|
const parsedBody = parsedOutput.body;
|
|
4209
|
-
|
|
4210
|
-
|
|
4211
|
-
...parsedBody.Error,
|
|
4212
|
-
name: `${errorCode}`,
|
|
4213
|
-
message: parsedBody.Error.message || parsedBody.Error.Message || errorCode,
|
|
3326
|
+
response = new CloudFormationServiceException_1.CloudFormationServiceException({
|
|
3327
|
+
name: parsedBody.Error.code || parsedBody.Error.Code || errorCode,
|
|
4214
3328
|
$fault: "client",
|
|
4215
3329
|
$metadata: deserializeMetadata(output),
|
|
4216
|
-
};
|
|
3330
|
+
});
|
|
3331
|
+
throw smithy_client_1.decorateServiceException(response, parsedBody.Error);
|
|
4217
3332
|
}
|
|
4218
|
-
const message = response.message || response.Message || errorCode;
|
|
4219
|
-
response.message = message;
|
|
4220
|
-
delete response.Message;
|
|
4221
|
-
return Promise.reject(Object.assign(new Error(message), response));
|
|
4222
3333
|
};
|
|
4223
3334
|
const deserializeAws_queryAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
|
|
4224
3335
|
const body = parsedOutput.body;
|
|
4225
3336
|
const deserialized = deserializeAws_queryAlreadyExistsException(body.Error, context);
|
|
4226
|
-
const
|
|
4227
|
-
name: "AlreadyExistsException",
|
|
4228
|
-
$fault: "client",
|
|
3337
|
+
const exception = new models_0_1.AlreadyExistsException({
|
|
4229
3338
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4230
3339
|
...deserialized,
|
|
4231
|
-
};
|
|
4232
|
-
return
|
|
3340
|
+
});
|
|
3341
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4233
3342
|
};
|
|
4234
3343
|
const deserializeAws_queryCFNRegistryExceptionResponse = async (parsedOutput, context) => {
|
|
4235
3344
|
const body = parsedOutput.body;
|
|
4236
3345
|
const deserialized = deserializeAws_queryCFNRegistryException(body.Error, context);
|
|
4237
|
-
const
|
|
4238
|
-
name: "CFNRegistryException",
|
|
4239
|
-
$fault: "client",
|
|
3346
|
+
const exception = new models_0_1.CFNRegistryException({
|
|
4240
3347
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4241
3348
|
...deserialized,
|
|
4242
|
-
};
|
|
4243
|
-
return
|
|
3349
|
+
});
|
|
3350
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4244
3351
|
};
|
|
4245
3352
|
const deserializeAws_queryChangeSetNotFoundExceptionResponse = async (parsedOutput, context) => {
|
|
4246
3353
|
const body = parsedOutput.body;
|
|
4247
3354
|
const deserialized = deserializeAws_queryChangeSetNotFoundException(body.Error, context);
|
|
4248
|
-
const
|
|
4249
|
-
name: "ChangeSetNotFoundException",
|
|
4250
|
-
$fault: "client",
|
|
3355
|
+
const exception = new models_0_1.ChangeSetNotFoundException({
|
|
4251
3356
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4252
3357
|
...deserialized,
|
|
4253
|
-
};
|
|
4254
|
-
return
|
|
3358
|
+
});
|
|
3359
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4255
3360
|
};
|
|
4256
3361
|
const deserializeAws_queryCreatedButModifiedExceptionResponse = async (parsedOutput, context) => {
|
|
4257
3362
|
const body = parsedOutput.body;
|
|
4258
3363
|
const deserialized = deserializeAws_queryCreatedButModifiedException(body.Error, context);
|
|
4259
|
-
const
|
|
4260
|
-
name: "CreatedButModifiedException",
|
|
4261
|
-
$fault: "client",
|
|
3364
|
+
const exception = new models_0_1.CreatedButModifiedException({
|
|
4262
3365
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4263
3366
|
...deserialized,
|
|
4264
|
-
};
|
|
4265
|
-
return
|
|
3367
|
+
});
|
|
3368
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4266
3369
|
};
|
|
4267
3370
|
const deserializeAws_queryInsufficientCapabilitiesExceptionResponse = async (parsedOutput, context) => {
|
|
4268
3371
|
const body = parsedOutput.body;
|
|
4269
3372
|
const deserialized = deserializeAws_queryInsufficientCapabilitiesException(body.Error, context);
|
|
4270
|
-
const
|
|
4271
|
-
name: "InsufficientCapabilitiesException",
|
|
4272
|
-
$fault: "client",
|
|
3373
|
+
const exception = new models_0_1.InsufficientCapabilitiesException({
|
|
4273
3374
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4274
3375
|
...deserialized,
|
|
4275
|
-
};
|
|
4276
|
-
return
|
|
3376
|
+
});
|
|
3377
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4277
3378
|
};
|
|
4278
3379
|
const deserializeAws_queryInvalidChangeSetStatusExceptionResponse = async (parsedOutput, context) => {
|
|
4279
3380
|
const body = parsedOutput.body;
|
|
4280
3381
|
const deserialized = deserializeAws_queryInvalidChangeSetStatusException(body.Error, context);
|
|
4281
|
-
const
|
|
4282
|
-
name: "InvalidChangeSetStatusException",
|
|
4283
|
-
$fault: "client",
|
|
3382
|
+
const exception = new models_0_1.InvalidChangeSetStatusException({
|
|
4284
3383
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4285
3384
|
...deserialized,
|
|
4286
|
-
};
|
|
4287
|
-
return
|
|
3385
|
+
});
|
|
3386
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4288
3387
|
};
|
|
4289
3388
|
const deserializeAws_queryInvalidOperationExceptionResponse = async (parsedOutput, context) => {
|
|
4290
3389
|
const body = parsedOutput.body;
|
|
4291
3390
|
const deserialized = deserializeAws_queryInvalidOperationException(body.Error, context);
|
|
4292
|
-
const
|
|
4293
|
-
name: "InvalidOperationException",
|
|
4294
|
-
$fault: "client",
|
|
3391
|
+
const exception = new models_0_1.InvalidOperationException({
|
|
4295
3392
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4296
3393
|
...deserialized,
|
|
4297
|
-
};
|
|
4298
|
-
return
|
|
3394
|
+
});
|
|
3395
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4299
3396
|
};
|
|
4300
3397
|
const deserializeAws_queryInvalidStateTransitionExceptionResponse = async (parsedOutput, context) => {
|
|
4301
3398
|
const body = parsedOutput.body;
|
|
4302
3399
|
const deserialized = deserializeAws_queryInvalidStateTransitionException(body.Error, context);
|
|
4303
|
-
const
|
|
4304
|
-
name: "InvalidStateTransitionException",
|
|
4305
|
-
$fault: "client",
|
|
3400
|
+
const exception = new models_0_1.InvalidStateTransitionException({
|
|
4306
3401
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4307
3402
|
...deserialized,
|
|
4308
|
-
};
|
|
4309
|
-
return
|
|
3403
|
+
});
|
|
3404
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4310
3405
|
};
|
|
4311
3406
|
const deserializeAws_queryLimitExceededExceptionResponse = async (parsedOutput, context) => {
|
|
4312
3407
|
const body = parsedOutput.body;
|
|
4313
3408
|
const deserialized = deserializeAws_queryLimitExceededException(body.Error, context);
|
|
4314
|
-
const
|
|
4315
|
-
name: "LimitExceededException",
|
|
4316
|
-
$fault: "client",
|
|
3409
|
+
const exception = new models_0_1.LimitExceededException({
|
|
4317
3410
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4318
3411
|
...deserialized,
|
|
4319
|
-
};
|
|
4320
|
-
return
|
|
3412
|
+
});
|
|
3413
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4321
3414
|
};
|
|
4322
3415
|
const deserializeAws_queryNameAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
|
|
4323
3416
|
const body = parsedOutput.body;
|
|
4324
3417
|
const deserialized = deserializeAws_queryNameAlreadyExistsException(body.Error, context);
|
|
4325
|
-
const
|
|
4326
|
-
name: "NameAlreadyExistsException",
|
|
4327
|
-
$fault: "client",
|
|
3418
|
+
const exception = new models_0_1.NameAlreadyExistsException({
|
|
4328
3419
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4329
3420
|
...deserialized,
|
|
4330
|
-
};
|
|
4331
|
-
return
|
|
3421
|
+
});
|
|
3422
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4332
3423
|
};
|
|
4333
3424
|
const deserializeAws_queryOperationIdAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
|
|
4334
3425
|
const body = parsedOutput.body;
|
|
4335
3426
|
const deserialized = deserializeAws_queryOperationIdAlreadyExistsException(body.Error, context);
|
|
4336
|
-
const
|
|
4337
|
-
name: "OperationIdAlreadyExistsException",
|
|
4338
|
-
$fault: "client",
|
|
3427
|
+
const exception = new models_0_1.OperationIdAlreadyExistsException({
|
|
4339
3428
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4340
3429
|
...deserialized,
|
|
4341
|
-
};
|
|
4342
|
-
return
|
|
3430
|
+
});
|
|
3431
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4343
3432
|
};
|
|
4344
3433
|
const deserializeAws_queryOperationInProgressExceptionResponse = async (parsedOutput, context) => {
|
|
4345
3434
|
const body = parsedOutput.body;
|
|
4346
3435
|
const deserialized = deserializeAws_queryOperationInProgressException(body.Error, context);
|
|
4347
|
-
const
|
|
4348
|
-
name: "OperationInProgressException",
|
|
4349
|
-
$fault: "client",
|
|
3436
|
+
const exception = new models_0_1.OperationInProgressException({
|
|
4350
3437
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4351
3438
|
...deserialized,
|
|
4352
|
-
};
|
|
4353
|
-
return
|
|
3439
|
+
});
|
|
3440
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4354
3441
|
};
|
|
4355
3442
|
const deserializeAws_queryOperationNotFoundExceptionResponse = async (parsedOutput, context) => {
|
|
4356
3443
|
const body = parsedOutput.body;
|
|
4357
3444
|
const deserialized = deserializeAws_queryOperationNotFoundException(body.Error, context);
|
|
4358
|
-
const
|
|
4359
|
-
name: "OperationNotFoundException",
|
|
4360
|
-
$fault: "client",
|
|
3445
|
+
const exception = new models_0_1.OperationNotFoundException({
|
|
4361
3446
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4362
3447
|
...deserialized,
|
|
4363
|
-
};
|
|
4364
|
-
return
|
|
3448
|
+
});
|
|
3449
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4365
3450
|
};
|
|
4366
3451
|
const deserializeAws_queryOperationStatusCheckFailedExceptionResponse = async (parsedOutput, context) => {
|
|
4367
3452
|
const body = parsedOutput.body;
|
|
4368
3453
|
const deserialized = deserializeAws_queryOperationStatusCheckFailedException(body.Error, context);
|
|
4369
|
-
const
|
|
4370
|
-
name: "OperationStatusCheckFailedException",
|
|
4371
|
-
$fault: "client",
|
|
3454
|
+
const exception = new models_0_1.OperationStatusCheckFailedException({
|
|
4372
3455
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4373
3456
|
...deserialized,
|
|
4374
|
-
};
|
|
4375
|
-
return
|
|
3457
|
+
});
|
|
3458
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4376
3459
|
};
|
|
4377
3460
|
const deserializeAws_queryStackInstanceNotFoundExceptionResponse = async (parsedOutput, context) => {
|
|
4378
3461
|
const body = parsedOutput.body;
|
|
4379
3462
|
const deserialized = deserializeAws_queryStackInstanceNotFoundException(body.Error, context);
|
|
4380
|
-
const
|
|
4381
|
-
name: "StackInstanceNotFoundException",
|
|
4382
|
-
$fault: "client",
|
|
3463
|
+
const exception = new models_0_1.StackInstanceNotFoundException({
|
|
4383
3464
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4384
3465
|
...deserialized,
|
|
4385
|
-
};
|
|
4386
|
-
return
|
|
3466
|
+
});
|
|
3467
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4387
3468
|
};
|
|
4388
3469
|
const deserializeAws_queryStackNotFoundExceptionResponse = async (parsedOutput, context) => {
|
|
4389
3470
|
const body = parsedOutput.body;
|
|
4390
3471
|
const deserialized = deserializeAws_queryStackNotFoundException(body.Error, context);
|
|
4391
|
-
const
|
|
4392
|
-
name: "StackNotFoundException",
|
|
4393
|
-
$fault: "client",
|
|
3472
|
+
const exception = new models_0_1.StackNotFoundException({
|
|
4394
3473
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4395
3474
|
...deserialized,
|
|
4396
|
-
};
|
|
4397
|
-
return
|
|
3475
|
+
});
|
|
3476
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4398
3477
|
};
|
|
4399
3478
|
const deserializeAws_queryStackSetNotEmptyExceptionResponse = async (parsedOutput, context) => {
|
|
4400
3479
|
const body = parsedOutput.body;
|
|
4401
3480
|
const deserialized = deserializeAws_queryStackSetNotEmptyException(body.Error, context);
|
|
4402
|
-
const
|
|
4403
|
-
name: "StackSetNotEmptyException",
|
|
4404
|
-
$fault: "client",
|
|
3481
|
+
const exception = new models_0_1.StackSetNotEmptyException({
|
|
4405
3482
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4406
3483
|
...deserialized,
|
|
4407
|
-
};
|
|
4408
|
-
return
|
|
3484
|
+
});
|
|
3485
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4409
3486
|
};
|
|
4410
3487
|
const deserializeAws_queryStackSetNotFoundExceptionResponse = async (parsedOutput, context) => {
|
|
4411
3488
|
const body = parsedOutput.body;
|
|
4412
3489
|
const deserialized = deserializeAws_queryStackSetNotFoundException(body.Error, context);
|
|
4413
|
-
const
|
|
4414
|
-
name: "StackSetNotFoundException",
|
|
4415
|
-
$fault: "client",
|
|
3490
|
+
const exception = new models_0_1.StackSetNotFoundException({
|
|
4416
3491
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4417
3492
|
...deserialized,
|
|
4418
|
-
};
|
|
4419
|
-
return
|
|
3493
|
+
});
|
|
3494
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4420
3495
|
};
|
|
4421
3496
|
const deserializeAws_queryStaleRequestExceptionResponse = async (parsedOutput, context) => {
|
|
4422
3497
|
const body = parsedOutput.body;
|
|
4423
3498
|
const deserialized = deserializeAws_queryStaleRequestException(body.Error, context);
|
|
4424
|
-
const
|
|
4425
|
-
name: "StaleRequestException",
|
|
4426
|
-
$fault: "client",
|
|
3499
|
+
const exception = new models_0_1.StaleRequestException({
|
|
4427
3500
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4428
3501
|
...deserialized,
|
|
4429
|
-
};
|
|
4430
|
-
return
|
|
3502
|
+
});
|
|
3503
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4431
3504
|
};
|
|
4432
3505
|
const deserializeAws_queryTokenAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
|
|
4433
3506
|
const body = parsedOutput.body;
|
|
4434
3507
|
const deserialized = deserializeAws_queryTokenAlreadyExistsException(body.Error, context);
|
|
4435
|
-
const
|
|
4436
|
-
name: "TokenAlreadyExistsException",
|
|
4437
|
-
$fault: "client",
|
|
3508
|
+
const exception = new models_0_1.TokenAlreadyExistsException({
|
|
4438
3509
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4439
3510
|
...deserialized,
|
|
4440
|
-
};
|
|
4441
|
-
return
|
|
3511
|
+
});
|
|
3512
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4442
3513
|
};
|
|
4443
3514
|
const deserializeAws_queryTypeConfigurationNotFoundExceptionResponse = async (parsedOutput, context) => {
|
|
4444
3515
|
const body = parsedOutput.body;
|
|
4445
3516
|
const deserialized = deserializeAws_queryTypeConfigurationNotFoundException(body.Error, context);
|
|
4446
|
-
const
|
|
4447
|
-
name: "TypeConfigurationNotFoundException",
|
|
4448
|
-
$fault: "client",
|
|
3517
|
+
const exception = new models_0_1.TypeConfigurationNotFoundException({
|
|
4449
3518
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4450
3519
|
...deserialized,
|
|
4451
|
-
};
|
|
4452
|
-
return
|
|
3520
|
+
});
|
|
3521
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4453
3522
|
};
|
|
4454
3523
|
const deserializeAws_queryTypeNotFoundExceptionResponse = async (parsedOutput, context) => {
|
|
4455
3524
|
const body = parsedOutput.body;
|
|
4456
3525
|
const deserialized = deserializeAws_queryTypeNotFoundException(body.Error, context);
|
|
4457
|
-
const
|
|
4458
|
-
name: "TypeNotFoundException",
|
|
4459
|
-
$fault: "client",
|
|
3526
|
+
const exception = new models_0_1.TypeNotFoundException({
|
|
4460
3527
|
$metadata: deserializeMetadata(parsedOutput),
|
|
4461
3528
|
...deserialized,
|
|
4462
|
-
};
|
|
4463
|
-
return
|
|
3529
|
+
});
|
|
3530
|
+
return smithy_client_1.decorateServiceException(exception, body);
|
|
4464
3531
|
};
|
|
4465
3532
|
const serializeAws_queryAccountList = (input, context) => {
|
|
4466
3533
|
const entries = {};
|