@aws-sdk/client-auto-scaling 3.504.0 → 3.509.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist-cjs/index.js +116 -1485
- package/dist-es/protocols/Aws_query.js +112 -1481
- package/package.json +3 -3
package/dist-cjs/index.js
CHANGED
|
@@ -1239,7 +1239,7 @@ var se_UpdateAutoScalingGroupCommand = /* @__PURE__ */ __name(async (input, cont
|
|
|
1239
1239
|
}, "se_UpdateAutoScalingGroupCommand");
|
|
1240
1240
|
var de_AttachInstancesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1241
1241
|
if (output.statusCode >= 300) {
|
|
1242
|
-
return
|
|
1242
|
+
return de_CommandError(output, context);
|
|
1243
1243
|
}
|
|
1244
1244
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
1245
1245
|
const response = {
|
|
@@ -1247,31 +1247,9 @@ var de_AttachInstancesCommand = /* @__PURE__ */ __name(async (output, context) =
|
|
|
1247
1247
|
};
|
|
1248
1248
|
return response;
|
|
1249
1249
|
}, "de_AttachInstancesCommand");
|
|
1250
|
-
var de_AttachInstancesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1251
|
-
const parsedOutput = {
|
|
1252
|
-
...output,
|
|
1253
|
-
body: await parseErrorBody(output.body, context)
|
|
1254
|
-
};
|
|
1255
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1256
|
-
switch (errorCode) {
|
|
1257
|
-
case "ResourceContention":
|
|
1258
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1259
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1260
|
-
case "ServiceLinkedRoleFailure":
|
|
1261
|
-
case "com.amazonaws.autoscaling#ServiceLinkedRoleFailure":
|
|
1262
|
-
throw await de_ServiceLinkedRoleFailureRes(parsedOutput, context);
|
|
1263
|
-
default:
|
|
1264
|
-
const parsedBody = parsedOutput.body;
|
|
1265
|
-
return throwDefaultError({
|
|
1266
|
-
output,
|
|
1267
|
-
parsedBody: parsedBody.Error,
|
|
1268
|
-
errorCode
|
|
1269
|
-
});
|
|
1270
|
-
}
|
|
1271
|
-
}, "de_AttachInstancesCommandError");
|
|
1272
1250
|
var de_AttachLoadBalancersCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1273
1251
|
if (output.statusCode >= 300) {
|
|
1274
|
-
return
|
|
1252
|
+
return de_CommandError(output, context);
|
|
1275
1253
|
}
|
|
1276
1254
|
const data = await parseBody(output.body, context);
|
|
1277
1255
|
let contents = {};
|
|
@@ -1282,31 +1260,9 @@ var de_AttachLoadBalancersCommand = /* @__PURE__ */ __name(async (output, contex
|
|
|
1282
1260
|
};
|
|
1283
1261
|
return response;
|
|
1284
1262
|
}, "de_AttachLoadBalancersCommand");
|
|
1285
|
-
var de_AttachLoadBalancersCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1286
|
-
const parsedOutput = {
|
|
1287
|
-
...output,
|
|
1288
|
-
body: await parseErrorBody(output.body, context)
|
|
1289
|
-
};
|
|
1290
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1291
|
-
switch (errorCode) {
|
|
1292
|
-
case "ResourceContention":
|
|
1293
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1294
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1295
|
-
case "ServiceLinkedRoleFailure":
|
|
1296
|
-
case "com.amazonaws.autoscaling#ServiceLinkedRoleFailure":
|
|
1297
|
-
throw await de_ServiceLinkedRoleFailureRes(parsedOutput, context);
|
|
1298
|
-
default:
|
|
1299
|
-
const parsedBody = parsedOutput.body;
|
|
1300
|
-
return throwDefaultError({
|
|
1301
|
-
output,
|
|
1302
|
-
parsedBody: parsedBody.Error,
|
|
1303
|
-
errorCode
|
|
1304
|
-
});
|
|
1305
|
-
}
|
|
1306
|
-
}, "de_AttachLoadBalancersCommandError");
|
|
1307
1263
|
var de_AttachLoadBalancerTargetGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1308
1264
|
if (output.statusCode >= 300) {
|
|
1309
|
-
return
|
|
1265
|
+
return de_CommandError(output, context);
|
|
1310
1266
|
}
|
|
1311
1267
|
const data = await parseBody(output.body, context);
|
|
1312
1268
|
let contents = {};
|
|
@@ -1317,31 +1273,9 @@ var de_AttachLoadBalancerTargetGroupsCommand = /* @__PURE__ */ __name(async (out
|
|
|
1317
1273
|
};
|
|
1318
1274
|
return response;
|
|
1319
1275
|
}, "de_AttachLoadBalancerTargetGroupsCommand");
|
|
1320
|
-
var de_AttachLoadBalancerTargetGroupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1321
|
-
const parsedOutput = {
|
|
1322
|
-
...output,
|
|
1323
|
-
body: await parseErrorBody(output.body, context)
|
|
1324
|
-
};
|
|
1325
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1326
|
-
switch (errorCode) {
|
|
1327
|
-
case "ResourceContention":
|
|
1328
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1329
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1330
|
-
case "ServiceLinkedRoleFailure":
|
|
1331
|
-
case "com.amazonaws.autoscaling#ServiceLinkedRoleFailure":
|
|
1332
|
-
throw await de_ServiceLinkedRoleFailureRes(parsedOutput, context);
|
|
1333
|
-
default:
|
|
1334
|
-
const parsedBody = parsedOutput.body;
|
|
1335
|
-
return throwDefaultError({
|
|
1336
|
-
output,
|
|
1337
|
-
parsedBody: parsedBody.Error,
|
|
1338
|
-
errorCode
|
|
1339
|
-
});
|
|
1340
|
-
}
|
|
1341
|
-
}, "de_AttachLoadBalancerTargetGroupsCommandError");
|
|
1342
1276
|
var de_AttachTrafficSourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1343
1277
|
if (output.statusCode >= 300) {
|
|
1344
|
-
return
|
|
1278
|
+
return de_CommandError(output, context);
|
|
1345
1279
|
}
|
|
1346
1280
|
const data = await parseBody(output.body, context);
|
|
1347
1281
|
let contents = {};
|
|
@@ -1352,31 +1286,9 @@ var de_AttachTrafficSourcesCommand = /* @__PURE__ */ __name(async (output, conte
|
|
|
1352
1286
|
};
|
|
1353
1287
|
return response;
|
|
1354
1288
|
}, "de_AttachTrafficSourcesCommand");
|
|
1355
|
-
var de_AttachTrafficSourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1356
|
-
const parsedOutput = {
|
|
1357
|
-
...output,
|
|
1358
|
-
body: await parseErrorBody(output.body, context)
|
|
1359
|
-
};
|
|
1360
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1361
|
-
switch (errorCode) {
|
|
1362
|
-
case "ResourceContention":
|
|
1363
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1364
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1365
|
-
case "ServiceLinkedRoleFailure":
|
|
1366
|
-
case "com.amazonaws.autoscaling#ServiceLinkedRoleFailure":
|
|
1367
|
-
throw await de_ServiceLinkedRoleFailureRes(parsedOutput, context);
|
|
1368
|
-
default:
|
|
1369
|
-
const parsedBody = parsedOutput.body;
|
|
1370
|
-
return throwDefaultError({
|
|
1371
|
-
output,
|
|
1372
|
-
parsedBody: parsedBody.Error,
|
|
1373
|
-
errorCode
|
|
1374
|
-
});
|
|
1375
|
-
}
|
|
1376
|
-
}, "de_AttachTrafficSourcesCommandError");
|
|
1377
1289
|
var de_BatchDeleteScheduledActionCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1378
1290
|
if (output.statusCode >= 300) {
|
|
1379
|
-
return
|
|
1291
|
+
return de_CommandError(output, context);
|
|
1380
1292
|
}
|
|
1381
1293
|
const data = await parseBody(output.body, context);
|
|
1382
1294
|
let contents = {};
|
|
@@ -1387,28 +1299,9 @@ var de_BatchDeleteScheduledActionCommand = /* @__PURE__ */ __name(async (output,
|
|
|
1387
1299
|
};
|
|
1388
1300
|
return response;
|
|
1389
1301
|
}, "de_BatchDeleteScheduledActionCommand");
|
|
1390
|
-
var de_BatchDeleteScheduledActionCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1391
|
-
const parsedOutput = {
|
|
1392
|
-
...output,
|
|
1393
|
-
body: await parseErrorBody(output.body, context)
|
|
1394
|
-
};
|
|
1395
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1396
|
-
switch (errorCode) {
|
|
1397
|
-
case "ResourceContention":
|
|
1398
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1399
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1400
|
-
default:
|
|
1401
|
-
const parsedBody = parsedOutput.body;
|
|
1402
|
-
return throwDefaultError({
|
|
1403
|
-
output,
|
|
1404
|
-
parsedBody: parsedBody.Error,
|
|
1405
|
-
errorCode
|
|
1406
|
-
});
|
|
1407
|
-
}
|
|
1408
|
-
}, "de_BatchDeleteScheduledActionCommandError");
|
|
1409
1302
|
var de_BatchPutScheduledUpdateGroupActionCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1410
1303
|
if (output.statusCode >= 300) {
|
|
1411
|
-
return
|
|
1304
|
+
return de_CommandError(output, context);
|
|
1412
1305
|
}
|
|
1413
1306
|
const data = await parseBody(output.body, context);
|
|
1414
1307
|
let contents = {};
|
|
@@ -1419,34 +1312,9 @@ var de_BatchPutScheduledUpdateGroupActionCommand = /* @__PURE__ */ __name(async
|
|
|
1419
1312
|
};
|
|
1420
1313
|
return response;
|
|
1421
1314
|
}, "de_BatchPutScheduledUpdateGroupActionCommand");
|
|
1422
|
-
var de_BatchPutScheduledUpdateGroupActionCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1423
|
-
const parsedOutput = {
|
|
1424
|
-
...output,
|
|
1425
|
-
body: await parseErrorBody(output.body, context)
|
|
1426
|
-
};
|
|
1427
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1428
|
-
switch (errorCode) {
|
|
1429
|
-
case "AlreadyExists":
|
|
1430
|
-
case "com.amazonaws.autoscaling#AlreadyExistsFault":
|
|
1431
|
-
throw await de_AlreadyExistsFaultRes(parsedOutput, context);
|
|
1432
|
-
case "LimitExceeded":
|
|
1433
|
-
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
1434
|
-
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
1435
|
-
case "ResourceContention":
|
|
1436
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1437
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1438
|
-
default:
|
|
1439
|
-
const parsedBody = parsedOutput.body;
|
|
1440
|
-
return throwDefaultError({
|
|
1441
|
-
output,
|
|
1442
|
-
parsedBody: parsedBody.Error,
|
|
1443
|
-
errorCode
|
|
1444
|
-
});
|
|
1445
|
-
}
|
|
1446
|
-
}, "de_BatchPutScheduledUpdateGroupActionCommandError");
|
|
1447
1315
|
var de_CancelInstanceRefreshCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1448
1316
|
if (output.statusCode >= 300) {
|
|
1449
|
-
return
|
|
1317
|
+
return de_CommandError(output, context);
|
|
1450
1318
|
}
|
|
1451
1319
|
const data = await parseBody(output.body, context);
|
|
1452
1320
|
let contents = {};
|
|
@@ -1457,34 +1325,9 @@ var de_CancelInstanceRefreshCommand = /* @__PURE__ */ __name(async (output, cont
|
|
|
1457
1325
|
};
|
|
1458
1326
|
return response;
|
|
1459
1327
|
}, "de_CancelInstanceRefreshCommand");
|
|
1460
|
-
var de_CancelInstanceRefreshCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1461
|
-
const parsedOutput = {
|
|
1462
|
-
...output,
|
|
1463
|
-
body: await parseErrorBody(output.body, context)
|
|
1464
|
-
};
|
|
1465
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1466
|
-
switch (errorCode) {
|
|
1467
|
-
case "ActiveInstanceRefreshNotFound":
|
|
1468
|
-
case "com.amazonaws.autoscaling#ActiveInstanceRefreshNotFoundFault":
|
|
1469
|
-
throw await de_ActiveInstanceRefreshNotFoundFaultRes(parsedOutput, context);
|
|
1470
|
-
case "LimitExceeded":
|
|
1471
|
-
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
1472
|
-
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
1473
|
-
case "ResourceContention":
|
|
1474
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1475
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1476
|
-
default:
|
|
1477
|
-
const parsedBody = parsedOutput.body;
|
|
1478
|
-
return throwDefaultError({
|
|
1479
|
-
output,
|
|
1480
|
-
parsedBody: parsedBody.Error,
|
|
1481
|
-
errorCode
|
|
1482
|
-
});
|
|
1483
|
-
}
|
|
1484
|
-
}, "de_CancelInstanceRefreshCommandError");
|
|
1485
1328
|
var de_CompleteLifecycleActionCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1486
1329
|
if (output.statusCode >= 300) {
|
|
1487
|
-
return
|
|
1330
|
+
return de_CommandError(output, context);
|
|
1488
1331
|
}
|
|
1489
1332
|
const data = await parseBody(output.body, context);
|
|
1490
1333
|
let contents = {};
|
|
@@ -1495,28 +1338,9 @@ var de_CompleteLifecycleActionCommand = /* @__PURE__ */ __name(async (output, co
|
|
|
1495
1338
|
};
|
|
1496
1339
|
return response;
|
|
1497
1340
|
}, "de_CompleteLifecycleActionCommand");
|
|
1498
|
-
var de_CompleteLifecycleActionCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1499
|
-
const parsedOutput = {
|
|
1500
|
-
...output,
|
|
1501
|
-
body: await parseErrorBody(output.body, context)
|
|
1502
|
-
};
|
|
1503
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1504
|
-
switch (errorCode) {
|
|
1505
|
-
case "ResourceContention":
|
|
1506
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1507
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1508
|
-
default:
|
|
1509
|
-
const parsedBody = parsedOutput.body;
|
|
1510
|
-
return throwDefaultError({
|
|
1511
|
-
output,
|
|
1512
|
-
parsedBody: parsedBody.Error,
|
|
1513
|
-
errorCode
|
|
1514
|
-
});
|
|
1515
|
-
}
|
|
1516
|
-
}, "de_CompleteLifecycleActionCommandError");
|
|
1517
1341
|
var de_CreateAutoScalingGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1518
1342
|
if (output.statusCode >= 300) {
|
|
1519
|
-
return
|
|
1343
|
+
return de_CommandError(output, context);
|
|
1520
1344
|
}
|
|
1521
1345
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
1522
1346
|
const response = {
|
|
@@ -1524,37 +1348,9 @@ var de_CreateAutoScalingGroupCommand = /* @__PURE__ */ __name(async (output, con
|
|
|
1524
1348
|
};
|
|
1525
1349
|
return response;
|
|
1526
1350
|
}, "de_CreateAutoScalingGroupCommand");
|
|
1527
|
-
var de_CreateAutoScalingGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1528
|
-
const parsedOutput = {
|
|
1529
|
-
...output,
|
|
1530
|
-
body: await parseErrorBody(output.body, context)
|
|
1531
|
-
};
|
|
1532
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1533
|
-
switch (errorCode) {
|
|
1534
|
-
case "AlreadyExists":
|
|
1535
|
-
case "com.amazonaws.autoscaling#AlreadyExistsFault":
|
|
1536
|
-
throw await de_AlreadyExistsFaultRes(parsedOutput, context);
|
|
1537
|
-
case "LimitExceeded":
|
|
1538
|
-
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
1539
|
-
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
1540
|
-
case "ResourceContention":
|
|
1541
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1542
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1543
|
-
case "ServiceLinkedRoleFailure":
|
|
1544
|
-
case "com.amazonaws.autoscaling#ServiceLinkedRoleFailure":
|
|
1545
|
-
throw await de_ServiceLinkedRoleFailureRes(parsedOutput, context);
|
|
1546
|
-
default:
|
|
1547
|
-
const parsedBody = parsedOutput.body;
|
|
1548
|
-
return throwDefaultError({
|
|
1549
|
-
output,
|
|
1550
|
-
parsedBody: parsedBody.Error,
|
|
1551
|
-
errorCode
|
|
1552
|
-
});
|
|
1553
|
-
}
|
|
1554
|
-
}, "de_CreateAutoScalingGroupCommandError");
|
|
1555
1351
|
var de_CreateLaunchConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1556
1352
|
if (output.statusCode >= 300) {
|
|
1557
|
-
return
|
|
1353
|
+
return de_CommandError(output, context);
|
|
1558
1354
|
}
|
|
1559
1355
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
1560
1356
|
const response = {
|
|
@@ -1562,34 +1358,9 @@ var de_CreateLaunchConfigurationCommand = /* @__PURE__ */ __name(async (output,
|
|
|
1562
1358
|
};
|
|
1563
1359
|
return response;
|
|
1564
1360
|
}, "de_CreateLaunchConfigurationCommand");
|
|
1565
|
-
var de_CreateLaunchConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1566
|
-
const parsedOutput = {
|
|
1567
|
-
...output,
|
|
1568
|
-
body: await parseErrorBody(output.body, context)
|
|
1569
|
-
};
|
|
1570
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1571
|
-
switch (errorCode) {
|
|
1572
|
-
case "AlreadyExists":
|
|
1573
|
-
case "com.amazonaws.autoscaling#AlreadyExistsFault":
|
|
1574
|
-
throw await de_AlreadyExistsFaultRes(parsedOutput, context);
|
|
1575
|
-
case "LimitExceeded":
|
|
1576
|
-
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
1577
|
-
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
1578
|
-
case "ResourceContention":
|
|
1579
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1580
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1581
|
-
default:
|
|
1582
|
-
const parsedBody = parsedOutput.body;
|
|
1583
|
-
return throwDefaultError({
|
|
1584
|
-
output,
|
|
1585
|
-
parsedBody: parsedBody.Error,
|
|
1586
|
-
errorCode
|
|
1587
|
-
});
|
|
1588
|
-
}
|
|
1589
|
-
}, "de_CreateLaunchConfigurationCommandError");
|
|
1590
1361
|
var de_CreateOrUpdateTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1591
1362
|
if (output.statusCode >= 300) {
|
|
1592
|
-
return
|
|
1363
|
+
return de_CommandError(output, context);
|
|
1593
1364
|
}
|
|
1594
1365
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
1595
1366
|
const response = {
|
|
@@ -1597,37 +1368,9 @@ var de_CreateOrUpdateTagsCommand = /* @__PURE__ */ __name(async (output, context
|
|
|
1597
1368
|
};
|
|
1598
1369
|
return response;
|
|
1599
1370
|
}, "de_CreateOrUpdateTagsCommand");
|
|
1600
|
-
var de_CreateOrUpdateTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1601
|
-
const parsedOutput = {
|
|
1602
|
-
...output,
|
|
1603
|
-
body: await parseErrorBody(output.body, context)
|
|
1604
|
-
};
|
|
1605
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1606
|
-
switch (errorCode) {
|
|
1607
|
-
case "AlreadyExists":
|
|
1608
|
-
case "com.amazonaws.autoscaling#AlreadyExistsFault":
|
|
1609
|
-
throw await de_AlreadyExistsFaultRes(parsedOutput, context);
|
|
1610
|
-
case "LimitExceeded":
|
|
1611
|
-
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
1612
|
-
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
1613
|
-
case "ResourceContention":
|
|
1614
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1615
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1616
|
-
case "ResourceInUse":
|
|
1617
|
-
case "com.amazonaws.autoscaling#ResourceInUseFault":
|
|
1618
|
-
throw await de_ResourceInUseFaultRes(parsedOutput, context);
|
|
1619
|
-
default:
|
|
1620
|
-
const parsedBody = parsedOutput.body;
|
|
1621
|
-
return throwDefaultError({
|
|
1622
|
-
output,
|
|
1623
|
-
parsedBody: parsedBody.Error,
|
|
1624
|
-
errorCode
|
|
1625
|
-
});
|
|
1626
|
-
}
|
|
1627
|
-
}, "de_CreateOrUpdateTagsCommandError");
|
|
1628
1371
|
var de_DeleteAutoScalingGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1629
1372
|
if (output.statusCode >= 300) {
|
|
1630
|
-
return
|
|
1373
|
+
return de_CommandError(output, context);
|
|
1631
1374
|
}
|
|
1632
1375
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
1633
1376
|
const response = {
|
|
@@ -1635,34 +1378,9 @@ var de_DeleteAutoScalingGroupCommand = /* @__PURE__ */ __name(async (output, con
|
|
|
1635
1378
|
};
|
|
1636
1379
|
return response;
|
|
1637
1380
|
}, "de_DeleteAutoScalingGroupCommand");
|
|
1638
|
-
var de_DeleteAutoScalingGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1639
|
-
const parsedOutput = {
|
|
1640
|
-
...output,
|
|
1641
|
-
body: await parseErrorBody(output.body, context)
|
|
1642
|
-
};
|
|
1643
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1644
|
-
switch (errorCode) {
|
|
1645
|
-
case "ResourceContention":
|
|
1646
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1647
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1648
|
-
case "ResourceInUse":
|
|
1649
|
-
case "com.amazonaws.autoscaling#ResourceInUseFault":
|
|
1650
|
-
throw await de_ResourceInUseFaultRes(parsedOutput, context);
|
|
1651
|
-
case "ScalingActivityInProgress":
|
|
1652
|
-
case "com.amazonaws.autoscaling#ScalingActivityInProgressFault":
|
|
1653
|
-
throw await de_ScalingActivityInProgressFaultRes(parsedOutput, context);
|
|
1654
|
-
default:
|
|
1655
|
-
const parsedBody = parsedOutput.body;
|
|
1656
|
-
return throwDefaultError({
|
|
1657
|
-
output,
|
|
1658
|
-
parsedBody: parsedBody.Error,
|
|
1659
|
-
errorCode
|
|
1660
|
-
});
|
|
1661
|
-
}
|
|
1662
|
-
}, "de_DeleteAutoScalingGroupCommandError");
|
|
1663
1381
|
var de_DeleteLaunchConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1664
1382
|
if (output.statusCode >= 300) {
|
|
1665
|
-
return
|
|
1383
|
+
return de_CommandError(output, context);
|
|
1666
1384
|
}
|
|
1667
1385
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
1668
1386
|
const response = {
|
|
@@ -1670,31 +1388,9 @@ var de_DeleteLaunchConfigurationCommand = /* @__PURE__ */ __name(async (output,
|
|
|
1670
1388
|
};
|
|
1671
1389
|
return response;
|
|
1672
1390
|
}, "de_DeleteLaunchConfigurationCommand");
|
|
1673
|
-
var de_DeleteLaunchConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1674
|
-
const parsedOutput = {
|
|
1675
|
-
...output,
|
|
1676
|
-
body: await parseErrorBody(output.body, context)
|
|
1677
|
-
};
|
|
1678
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1679
|
-
switch (errorCode) {
|
|
1680
|
-
case "ResourceContention":
|
|
1681
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1682
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1683
|
-
case "ResourceInUse":
|
|
1684
|
-
case "com.amazonaws.autoscaling#ResourceInUseFault":
|
|
1685
|
-
throw await de_ResourceInUseFaultRes(parsedOutput, context);
|
|
1686
|
-
default:
|
|
1687
|
-
const parsedBody = parsedOutput.body;
|
|
1688
|
-
return throwDefaultError({
|
|
1689
|
-
output,
|
|
1690
|
-
parsedBody: parsedBody.Error,
|
|
1691
|
-
errorCode
|
|
1692
|
-
});
|
|
1693
|
-
}
|
|
1694
|
-
}, "de_DeleteLaunchConfigurationCommandError");
|
|
1695
1391
|
var de_DeleteLifecycleHookCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1696
1392
|
if (output.statusCode >= 300) {
|
|
1697
|
-
return
|
|
1393
|
+
return de_CommandError(output, context);
|
|
1698
1394
|
}
|
|
1699
1395
|
const data = await parseBody(output.body, context);
|
|
1700
1396
|
let contents = {};
|
|
@@ -1705,57 +1401,19 @@ var de_DeleteLifecycleHookCommand = /* @__PURE__ */ __name(async (output, contex
|
|
|
1705
1401
|
};
|
|
1706
1402
|
return response;
|
|
1707
1403
|
}, "de_DeleteLifecycleHookCommand");
|
|
1708
|
-
var de_DeleteLifecycleHookCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1709
|
-
const parsedOutput = {
|
|
1710
|
-
...output,
|
|
1711
|
-
body: await parseErrorBody(output.body, context)
|
|
1712
|
-
};
|
|
1713
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1714
|
-
switch (errorCode) {
|
|
1715
|
-
case "ResourceContention":
|
|
1716
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1717
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1718
|
-
default:
|
|
1719
|
-
const parsedBody = parsedOutput.body;
|
|
1720
|
-
return throwDefaultError({
|
|
1721
|
-
output,
|
|
1722
|
-
parsedBody: parsedBody.Error,
|
|
1723
|
-
errorCode
|
|
1724
|
-
});
|
|
1725
|
-
}
|
|
1726
|
-
}, "de_DeleteLifecycleHookCommandError");
|
|
1727
1404
|
var de_DeleteNotificationConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1728
1405
|
if (output.statusCode >= 300) {
|
|
1729
|
-
return
|
|
1406
|
+
return de_CommandError(output, context);
|
|
1730
1407
|
}
|
|
1731
1408
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
1732
1409
|
const response = {
|
|
1733
1410
|
$metadata: deserializeMetadata(output)
|
|
1734
|
-
};
|
|
1735
|
-
return response;
|
|
1736
|
-
}, "de_DeleteNotificationConfigurationCommand");
|
|
1737
|
-
var de_DeleteNotificationConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1738
|
-
const parsedOutput = {
|
|
1739
|
-
...output,
|
|
1740
|
-
body: await parseErrorBody(output.body, context)
|
|
1741
|
-
};
|
|
1742
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1743
|
-
switch (errorCode) {
|
|
1744
|
-
case "ResourceContention":
|
|
1745
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1746
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1747
|
-
default:
|
|
1748
|
-
const parsedBody = parsedOutput.body;
|
|
1749
|
-
return throwDefaultError({
|
|
1750
|
-
output,
|
|
1751
|
-
parsedBody: parsedBody.Error,
|
|
1752
|
-
errorCode
|
|
1753
|
-
});
|
|
1754
|
-
}
|
|
1755
|
-
}, "de_DeleteNotificationConfigurationCommandError");
|
|
1411
|
+
};
|
|
1412
|
+
return response;
|
|
1413
|
+
}, "de_DeleteNotificationConfigurationCommand");
|
|
1756
1414
|
var de_DeletePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1757
1415
|
if (output.statusCode >= 300) {
|
|
1758
|
-
return
|
|
1416
|
+
return de_CommandError(output, context);
|
|
1759
1417
|
}
|
|
1760
1418
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
1761
1419
|
const response = {
|
|
@@ -1763,31 +1421,9 @@ var de_DeletePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
|
1763
1421
|
};
|
|
1764
1422
|
return response;
|
|
1765
1423
|
}, "de_DeletePolicyCommand");
|
|
1766
|
-
var de_DeletePolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1767
|
-
const parsedOutput = {
|
|
1768
|
-
...output,
|
|
1769
|
-
body: await parseErrorBody(output.body, context)
|
|
1770
|
-
};
|
|
1771
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1772
|
-
switch (errorCode) {
|
|
1773
|
-
case "ResourceContention":
|
|
1774
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1775
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1776
|
-
case "ServiceLinkedRoleFailure":
|
|
1777
|
-
case "com.amazonaws.autoscaling#ServiceLinkedRoleFailure":
|
|
1778
|
-
throw await de_ServiceLinkedRoleFailureRes(parsedOutput, context);
|
|
1779
|
-
default:
|
|
1780
|
-
const parsedBody = parsedOutput.body;
|
|
1781
|
-
return throwDefaultError({
|
|
1782
|
-
output,
|
|
1783
|
-
parsedBody: parsedBody.Error,
|
|
1784
|
-
errorCode
|
|
1785
|
-
});
|
|
1786
|
-
}
|
|
1787
|
-
}, "de_DeletePolicyCommandError");
|
|
1788
1424
|
var de_DeleteScheduledActionCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1789
1425
|
if (output.statusCode >= 300) {
|
|
1790
|
-
return
|
|
1426
|
+
return de_CommandError(output, context);
|
|
1791
1427
|
}
|
|
1792
1428
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
1793
1429
|
const response = {
|
|
@@ -1795,28 +1431,9 @@ var de_DeleteScheduledActionCommand = /* @__PURE__ */ __name(async (output, cont
|
|
|
1795
1431
|
};
|
|
1796
1432
|
return response;
|
|
1797
1433
|
}, "de_DeleteScheduledActionCommand");
|
|
1798
|
-
var de_DeleteScheduledActionCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1799
|
-
const parsedOutput = {
|
|
1800
|
-
...output,
|
|
1801
|
-
body: await parseErrorBody(output.body, context)
|
|
1802
|
-
};
|
|
1803
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1804
|
-
switch (errorCode) {
|
|
1805
|
-
case "ResourceContention":
|
|
1806
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1807
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1808
|
-
default:
|
|
1809
|
-
const parsedBody = parsedOutput.body;
|
|
1810
|
-
return throwDefaultError({
|
|
1811
|
-
output,
|
|
1812
|
-
parsedBody: parsedBody.Error,
|
|
1813
|
-
errorCode
|
|
1814
|
-
});
|
|
1815
|
-
}
|
|
1816
|
-
}, "de_DeleteScheduledActionCommandError");
|
|
1817
1434
|
var de_DeleteTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1818
1435
|
if (output.statusCode >= 300) {
|
|
1819
|
-
return
|
|
1436
|
+
return de_CommandError(output, context);
|
|
1820
1437
|
}
|
|
1821
1438
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
1822
1439
|
const response = {
|
|
@@ -1824,31 +1441,9 @@ var de_DeleteTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
|
1824
1441
|
};
|
|
1825
1442
|
return response;
|
|
1826
1443
|
}, "de_DeleteTagsCommand");
|
|
1827
|
-
var de_DeleteTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1828
|
-
const parsedOutput = {
|
|
1829
|
-
...output,
|
|
1830
|
-
body: await parseErrorBody(output.body, context)
|
|
1831
|
-
};
|
|
1832
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1833
|
-
switch (errorCode) {
|
|
1834
|
-
case "ResourceContention":
|
|
1835
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1836
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1837
|
-
case "ResourceInUse":
|
|
1838
|
-
case "com.amazonaws.autoscaling#ResourceInUseFault":
|
|
1839
|
-
throw await de_ResourceInUseFaultRes(parsedOutput, context);
|
|
1840
|
-
default:
|
|
1841
|
-
const parsedBody = parsedOutput.body;
|
|
1842
|
-
return throwDefaultError({
|
|
1843
|
-
output,
|
|
1844
|
-
parsedBody: parsedBody.Error,
|
|
1845
|
-
errorCode
|
|
1846
|
-
});
|
|
1847
|
-
}
|
|
1848
|
-
}, "de_DeleteTagsCommandError");
|
|
1849
1444
|
var de_DeleteWarmPoolCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1850
1445
|
if (output.statusCode >= 300) {
|
|
1851
|
-
return
|
|
1446
|
+
return de_CommandError(output, context);
|
|
1852
1447
|
}
|
|
1853
1448
|
const data = await parseBody(output.body, context);
|
|
1854
1449
|
let contents = {};
|
|
@@ -1859,37 +1454,9 @@ var de_DeleteWarmPoolCommand = /* @__PURE__ */ __name(async (output, context) =>
|
|
|
1859
1454
|
};
|
|
1860
1455
|
return response;
|
|
1861
1456
|
}, "de_DeleteWarmPoolCommand");
|
|
1862
|
-
var de_DeleteWarmPoolCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1863
|
-
const parsedOutput = {
|
|
1864
|
-
...output,
|
|
1865
|
-
body: await parseErrorBody(output.body, context)
|
|
1866
|
-
};
|
|
1867
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1868
|
-
switch (errorCode) {
|
|
1869
|
-
case "LimitExceeded":
|
|
1870
|
-
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
1871
|
-
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
1872
|
-
case "ResourceContention":
|
|
1873
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1874
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1875
|
-
case "ResourceInUse":
|
|
1876
|
-
case "com.amazonaws.autoscaling#ResourceInUseFault":
|
|
1877
|
-
throw await de_ResourceInUseFaultRes(parsedOutput, context);
|
|
1878
|
-
case "ScalingActivityInProgress":
|
|
1879
|
-
case "com.amazonaws.autoscaling#ScalingActivityInProgressFault":
|
|
1880
|
-
throw await de_ScalingActivityInProgressFaultRes(parsedOutput, context);
|
|
1881
|
-
default:
|
|
1882
|
-
const parsedBody = parsedOutput.body;
|
|
1883
|
-
return throwDefaultError({
|
|
1884
|
-
output,
|
|
1885
|
-
parsedBody: parsedBody.Error,
|
|
1886
|
-
errorCode
|
|
1887
|
-
});
|
|
1888
|
-
}
|
|
1889
|
-
}, "de_DeleteWarmPoolCommandError");
|
|
1890
1457
|
var de_DescribeAccountLimitsCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1891
1458
|
if (output.statusCode >= 300) {
|
|
1892
|
-
return
|
|
1459
|
+
return de_CommandError(output, context);
|
|
1893
1460
|
}
|
|
1894
1461
|
const data = await parseBody(output.body, context);
|
|
1895
1462
|
let contents = {};
|
|
@@ -1900,28 +1467,9 @@ var de_DescribeAccountLimitsCommand = /* @__PURE__ */ __name(async (output, cont
|
|
|
1900
1467
|
};
|
|
1901
1468
|
return response;
|
|
1902
1469
|
}, "de_DescribeAccountLimitsCommand");
|
|
1903
|
-
var de_DescribeAccountLimitsCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1904
|
-
const parsedOutput = {
|
|
1905
|
-
...output,
|
|
1906
|
-
body: await parseErrorBody(output.body, context)
|
|
1907
|
-
};
|
|
1908
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1909
|
-
switch (errorCode) {
|
|
1910
|
-
case "ResourceContention":
|
|
1911
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1912
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1913
|
-
default:
|
|
1914
|
-
const parsedBody = parsedOutput.body;
|
|
1915
|
-
return throwDefaultError({
|
|
1916
|
-
output,
|
|
1917
|
-
parsedBody: parsedBody.Error,
|
|
1918
|
-
errorCode
|
|
1919
|
-
});
|
|
1920
|
-
}
|
|
1921
|
-
}, "de_DescribeAccountLimitsCommandError");
|
|
1922
1470
|
var de_DescribeAdjustmentTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1923
1471
|
if (output.statusCode >= 300) {
|
|
1924
|
-
return
|
|
1472
|
+
return de_CommandError(output, context);
|
|
1925
1473
|
}
|
|
1926
1474
|
const data = await parseBody(output.body, context);
|
|
1927
1475
|
let contents = {};
|
|
@@ -1932,28 +1480,9 @@ var de_DescribeAdjustmentTypesCommand = /* @__PURE__ */ __name(async (output, co
|
|
|
1932
1480
|
};
|
|
1933
1481
|
return response;
|
|
1934
1482
|
}, "de_DescribeAdjustmentTypesCommand");
|
|
1935
|
-
var de_DescribeAdjustmentTypesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1936
|
-
const parsedOutput = {
|
|
1937
|
-
...output,
|
|
1938
|
-
body: await parseErrorBody(output.body, context)
|
|
1939
|
-
};
|
|
1940
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1941
|
-
switch (errorCode) {
|
|
1942
|
-
case "ResourceContention":
|
|
1943
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1944
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1945
|
-
default:
|
|
1946
|
-
const parsedBody = parsedOutput.body;
|
|
1947
|
-
return throwDefaultError({
|
|
1948
|
-
output,
|
|
1949
|
-
parsedBody: parsedBody.Error,
|
|
1950
|
-
errorCode
|
|
1951
|
-
});
|
|
1952
|
-
}
|
|
1953
|
-
}, "de_DescribeAdjustmentTypesCommandError");
|
|
1954
1483
|
var de_DescribeAutoScalingGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1955
1484
|
if (output.statusCode >= 300) {
|
|
1956
|
-
return
|
|
1485
|
+
return de_CommandError(output, context);
|
|
1957
1486
|
}
|
|
1958
1487
|
const data = await parseBody(output.body, context);
|
|
1959
1488
|
let contents = {};
|
|
@@ -1964,31 +1493,9 @@ var de_DescribeAutoScalingGroupsCommand = /* @__PURE__ */ __name(async (output,
|
|
|
1964
1493
|
};
|
|
1965
1494
|
return response;
|
|
1966
1495
|
}, "de_DescribeAutoScalingGroupsCommand");
|
|
1967
|
-
var de_DescribeAutoScalingGroupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
1968
|
-
const parsedOutput = {
|
|
1969
|
-
...output,
|
|
1970
|
-
body: await parseErrorBody(output.body, context)
|
|
1971
|
-
};
|
|
1972
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
1973
|
-
switch (errorCode) {
|
|
1974
|
-
case "InvalidNextToken":
|
|
1975
|
-
case "com.amazonaws.autoscaling#InvalidNextToken":
|
|
1976
|
-
throw await de_InvalidNextTokenRes(parsedOutput, context);
|
|
1977
|
-
case "ResourceContention":
|
|
1978
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
1979
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
1980
|
-
default:
|
|
1981
|
-
const parsedBody = parsedOutput.body;
|
|
1982
|
-
return throwDefaultError({
|
|
1983
|
-
output,
|
|
1984
|
-
parsedBody: parsedBody.Error,
|
|
1985
|
-
errorCode
|
|
1986
|
-
});
|
|
1987
|
-
}
|
|
1988
|
-
}, "de_DescribeAutoScalingGroupsCommandError");
|
|
1989
1496
|
var de_DescribeAutoScalingInstancesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1990
1497
|
if (output.statusCode >= 300) {
|
|
1991
|
-
return
|
|
1498
|
+
return de_CommandError(output, context);
|
|
1992
1499
|
}
|
|
1993
1500
|
const data = await parseBody(output.body, context);
|
|
1994
1501
|
let contents = {};
|
|
@@ -1999,31 +1506,9 @@ var de_DescribeAutoScalingInstancesCommand = /* @__PURE__ */ __name(async (outpu
|
|
|
1999
1506
|
};
|
|
2000
1507
|
return response;
|
|
2001
1508
|
}, "de_DescribeAutoScalingInstancesCommand");
|
|
2002
|
-
var de_DescribeAutoScalingInstancesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2003
|
-
const parsedOutput = {
|
|
2004
|
-
...output,
|
|
2005
|
-
body: await parseErrorBody(output.body, context)
|
|
2006
|
-
};
|
|
2007
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2008
|
-
switch (errorCode) {
|
|
2009
|
-
case "InvalidNextToken":
|
|
2010
|
-
case "com.amazonaws.autoscaling#InvalidNextToken":
|
|
2011
|
-
throw await de_InvalidNextTokenRes(parsedOutput, context);
|
|
2012
|
-
case "ResourceContention":
|
|
2013
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2014
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2015
|
-
default:
|
|
2016
|
-
const parsedBody = parsedOutput.body;
|
|
2017
|
-
return throwDefaultError({
|
|
2018
|
-
output,
|
|
2019
|
-
parsedBody: parsedBody.Error,
|
|
2020
|
-
errorCode
|
|
2021
|
-
});
|
|
2022
|
-
}
|
|
2023
|
-
}, "de_DescribeAutoScalingInstancesCommandError");
|
|
2024
1509
|
var de_DescribeAutoScalingNotificationTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2025
1510
|
if (output.statusCode >= 300) {
|
|
2026
|
-
return
|
|
1511
|
+
return de_CommandError(output, context);
|
|
2027
1512
|
}
|
|
2028
1513
|
const data = await parseBody(output.body, context);
|
|
2029
1514
|
let contents = {};
|
|
@@ -2034,28 +1519,9 @@ var de_DescribeAutoScalingNotificationTypesCommand = /* @__PURE__ */ __name(asyn
|
|
|
2034
1519
|
};
|
|
2035
1520
|
return response;
|
|
2036
1521
|
}, "de_DescribeAutoScalingNotificationTypesCommand");
|
|
2037
|
-
var de_DescribeAutoScalingNotificationTypesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2038
|
-
const parsedOutput = {
|
|
2039
|
-
...output,
|
|
2040
|
-
body: await parseErrorBody(output.body, context)
|
|
2041
|
-
};
|
|
2042
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2043
|
-
switch (errorCode) {
|
|
2044
|
-
case "ResourceContention":
|
|
2045
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2046
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2047
|
-
default:
|
|
2048
|
-
const parsedBody = parsedOutput.body;
|
|
2049
|
-
return throwDefaultError({
|
|
2050
|
-
output,
|
|
2051
|
-
parsedBody: parsedBody.Error,
|
|
2052
|
-
errorCode
|
|
2053
|
-
});
|
|
2054
|
-
}
|
|
2055
|
-
}, "de_DescribeAutoScalingNotificationTypesCommandError");
|
|
2056
1522
|
var de_DescribeInstanceRefreshesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2057
1523
|
if (output.statusCode >= 300) {
|
|
2058
|
-
return
|
|
1524
|
+
return de_CommandError(output, context);
|
|
2059
1525
|
}
|
|
2060
1526
|
const data = await parseBody(output.body, context);
|
|
2061
1527
|
let contents = {};
|
|
@@ -2066,31 +1532,9 @@ var de_DescribeInstanceRefreshesCommand = /* @__PURE__ */ __name(async (output,
|
|
|
2066
1532
|
};
|
|
2067
1533
|
return response;
|
|
2068
1534
|
}, "de_DescribeInstanceRefreshesCommand");
|
|
2069
|
-
var de_DescribeInstanceRefreshesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2070
|
-
const parsedOutput = {
|
|
2071
|
-
...output,
|
|
2072
|
-
body: await parseErrorBody(output.body, context)
|
|
2073
|
-
};
|
|
2074
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2075
|
-
switch (errorCode) {
|
|
2076
|
-
case "InvalidNextToken":
|
|
2077
|
-
case "com.amazonaws.autoscaling#InvalidNextToken":
|
|
2078
|
-
throw await de_InvalidNextTokenRes(parsedOutput, context);
|
|
2079
|
-
case "ResourceContention":
|
|
2080
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2081
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2082
|
-
default:
|
|
2083
|
-
const parsedBody = parsedOutput.body;
|
|
2084
|
-
return throwDefaultError({
|
|
2085
|
-
output,
|
|
2086
|
-
parsedBody: parsedBody.Error,
|
|
2087
|
-
errorCode
|
|
2088
|
-
});
|
|
2089
|
-
}
|
|
2090
|
-
}, "de_DescribeInstanceRefreshesCommandError");
|
|
2091
1535
|
var de_DescribeLaunchConfigurationsCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2092
1536
|
if (output.statusCode >= 300) {
|
|
2093
|
-
return
|
|
1537
|
+
return de_CommandError(output, context);
|
|
2094
1538
|
}
|
|
2095
1539
|
const data = await parseBody(output.body, context);
|
|
2096
1540
|
let contents = {};
|
|
@@ -2101,31 +1545,9 @@ var de_DescribeLaunchConfigurationsCommand = /* @__PURE__ */ __name(async (outpu
|
|
|
2101
1545
|
};
|
|
2102
1546
|
return response;
|
|
2103
1547
|
}, "de_DescribeLaunchConfigurationsCommand");
|
|
2104
|
-
var de_DescribeLaunchConfigurationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2105
|
-
const parsedOutput = {
|
|
2106
|
-
...output,
|
|
2107
|
-
body: await parseErrorBody(output.body, context)
|
|
2108
|
-
};
|
|
2109
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2110
|
-
switch (errorCode) {
|
|
2111
|
-
case "InvalidNextToken":
|
|
2112
|
-
case "com.amazonaws.autoscaling#InvalidNextToken":
|
|
2113
|
-
throw await de_InvalidNextTokenRes(parsedOutput, context);
|
|
2114
|
-
case "ResourceContention":
|
|
2115
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2116
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2117
|
-
default:
|
|
2118
|
-
const parsedBody = parsedOutput.body;
|
|
2119
|
-
return throwDefaultError({
|
|
2120
|
-
output,
|
|
2121
|
-
parsedBody: parsedBody.Error,
|
|
2122
|
-
errorCode
|
|
2123
|
-
});
|
|
2124
|
-
}
|
|
2125
|
-
}, "de_DescribeLaunchConfigurationsCommandError");
|
|
2126
1548
|
var de_DescribeLifecycleHooksCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2127
1549
|
if (output.statusCode >= 300) {
|
|
2128
|
-
return
|
|
1550
|
+
return de_CommandError(output, context);
|
|
2129
1551
|
}
|
|
2130
1552
|
const data = await parseBody(output.body, context);
|
|
2131
1553
|
let contents = {};
|
|
@@ -2136,60 +1558,22 @@ var de_DescribeLifecycleHooksCommand = /* @__PURE__ */ __name(async (output, con
|
|
|
2136
1558
|
};
|
|
2137
1559
|
return response;
|
|
2138
1560
|
}, "de_DescribeLifecycleHooksCommand");
|
|
2139
|
-
var de_DescribeLifecycleHooksCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2140
|
-
const parsedOutput = {
|
|
2141
|
-
...output,
|
|
2142
|
-
body: await parseErrorBody(output.body, context)
|
|
2143
|
-
};
|
|
2144
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2145
|
-
switch (errorCode) {
|
|
2146
|
-
case "ResourceContention":
|
|
2147
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2148
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2149
|
-
default:
|
|
2150
|
-
const parsedBody = parsedOutput.body;
|
|
2151
|
-
return throwDefaultError({
|
|
2152
|
-
output,
|
|
2153
|
-
parsedBody: parsedBody.Error,
|
|
2154
|
-
errorCode
|
|
2155
|
-
});
|
|
2156
|
-
}
|
|
2157
|
-
}, "de_DescribeLifecycleHooksCommandError");
|
|
2158
1561
|
var de_DescribeLifecycleHookTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2159
1562
|
if (output.statusCode >= 300) {
|
|
2160
|
-
return
|
|
1563
|
+
return de_CommandError(output, context);
|
|
2161
1564
|
}
|
|
2162
1565
|
const data = await parseBody(output.body, context);
|
|
2163
1566
|
let contents = {};
|
|
2164
1567
|
contents = de_DescribeLifecycleHookTypesAnswer(data.DescribeLifecycleHookTypesResult, context);
|
|
2165
1568
|
const response = {
|
|
2166
|
-
$metadata: deserializeMetadata(output),
|
|
2167
|
-
...contents
|
|
2168
|
-
};
|
|
2169
|
-
return response;
|
|
2170
|
-
}, "de_DescribeLifecycleHookTypesCommand");
|
|
2171
|
-
var de_DescribeLifecycleHookTypesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2172
|
-
const parsedOutput = {
|
|
2173
|
-
...output,
|
|
2174
|
-
body: await parseErrorBody(output.body, context)
|
|
2175
|
-
};
|
|
2176
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2177
|
-
switch (errorCode) {
|
|
2178
|
-
case "ResourceContention":
|
|
2179
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2180
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2181
|
-
default:
|
|
2182
|
-
const parsedBody = parsedOutput.body;
|
|
2183
|
-
return throwDefaultError({
|
|
2184
|
-
output,
|
|
2185
|
-
parsedBody: parsedBody.Error,
|
|
2186
|
-
errorCode
|
|
2187
|
-
});
|
|
2188
|
-
}
|
|
2189
|
-
}, "de_DescribeLifecycleHookTypesCommandError");
|
|
1569
|
+
$metadata: deserializeMetadata(output),
|
|
1570
|
+
...contents
|
|
1571
|
+
};
|
|
1572
|
+
return response;
|
|
1573
|
+
}, "de_DescribeLifecycleHookTypesCommand");
|
|
2190
1574
|
var de_DescribeLoadBalancersCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2191
1575
|
if (output.statusCode >= 300) {
|
|
2192
|
-
return
|
|
1576
|
+
return de_CommandError(output, context);
|
|
2193
1577
|
}
|
|
2194
1578
|
const data = await parseBody(output.body, context);
|
|
2195
1579
|
let contents = {};
|
|
@@ -2200,31 +1584,9 @@ var de_DescribeLoadBalancersCommand = /* @__PURE__ */ __name(async (output, cont
|
|
|
2200
1584
|
};
|
|
2201
1585
|
return response;
|
|
2202
1586
|
}, "de_DescribeLoadBalancersCommand");
|
|
2203
|
-
var de_DescribeLoadBalancersCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2204
|
-
const parsedOutput = {
|
|
2205
|
-
...output,
|
|
2206
|
-
body: await parseErrorBody(output.body, context)
|
|
2207
|
-
};
|
|
2208
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2209
|
-
switch (errorCode) {
|
|
2210
|
-
case "InvalidNextToken":
|
|
2211
|
-
case "com.amazonaws.autoscaling#InvalidNextToken":
|
|
2212
|
-
throw await de_InvalidNextTokenRes(parsedOutput, context);
|
|
2213
|
-
case "ResourceContention":
|
|
2214
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2215
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2216
|
-
default:
|
|
2217
|
-
const parsedBody = parsedOutput.body;
|
|
2218
|
-
return throwDefaultError({
|
|
2219
|
-
output,
|
|
2220
|
-
parsedBody: parsedBody.Error,
|
|
2221
|
-
errorCode
|
|
2222
|
-
});
|
|
2223
|
-
}
|
|
2224
|
-
}, "de_DescribeLoadBalancersCommandError");
|
|
2225
1587
|
var de_DescribeLoadBalancerTargetGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2226
1588
|
if (output.statusCode >= 300) {
|
|
2227
|
-
return
|
|
1589
|
+
return de_CommandError(output, context);
|
|
2228
1590
|
}
|
|
2229
1591
|
const data = await parseBody(output.body, context);
|
|
2230
1592
|
let contents = {};
|
|
@@ -2235,31 +1597,9 @@ var de_DescribeLoadBalancerTargetGroupsCommand = /* @__PURE__ */ __name(async (o
|
|
|
2235
1597
|
};
|
|
2236
1598
|
return response;
|
|
2237
1599
|
}, "de_DescribeLoadBalancerTargetGroupsCommand");
|
|
2238
|
-
var de_DescribeLoadBalancerTargetGroupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2239
|
-
const parsedOutput = {
|
|
2240
|
-
...output,
|
|
2241
|
-
body: await parseErrorBody(output.body, context)
|
|
2242
|
-
};
|
|
2243
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2244
|
-
switch (errorCode) {
|
|
2245
|
-
case "InvalidNextToken":
|
|
2246
|
-
case "com.amazonaws.autoscaling#InvalidNextToken":
|
|
2247
|
-
throw await de_InvalidNextTokenRes(parsedOutput, context);
|
|
2248
|
-
case "ResourceContention":
|
|
2249
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2250
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2251
|
-
default:
|
|
2252
|
-
const parsedBody = parsedOutput.body;
|
|
2253
|
-
return throwDefaultError({
|
|
2254
|
-
output,
|
|
2255
|
-
parsedBody: parsedBody.Error,
|
|
2256
|
-
errorCode
|
|
2257
|
-
});
|
|
2258
|
-
}
|
|
2259
|
-
}, "de_DescribeLoadBalancerTargetGroupsCommandError");
|
|
2260
1600
|
var de_DescribeMetricCollectionTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2261
1601
|
if (output.statusCode >= 300) {
|
|
2262
|
-
return
|
|
1602
|
+
return de_CommandError(output, context);
|
|
2263
1603
|
}
|
|
2264
1604
|
const data = await parseBody(output.body, context);
|
|
2265
1605
|
let contents = {};
|
|
@@ -2270,28 +1610,9 @@ var de_DescribeMetricCollectionTypesCommand = /* @__PURE__ */ __name(async (outp
|
|
|
2270
1610
|
};
|
|
2271
1611
|
return response;
|
|
2272
1612
|
}, "de_DescribeMetricCollectionTypesCommand");
|
|
2273
|
-
var de_DescribeMetricCollectionTypesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2274
|
-
const parsedOutput = {
|
|
2275
|
-
...output,
|
|
2276
|
-
body: await parseErrorBody(output.body, context)
|
|
2277
|
-
};
|
|
2278
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2279
|
-
switch (errorCode) {
|
|
2280
|
-
case "ResourceContention":
|
|
2281
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2282
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2283
|
-
default:
|
|
2284
|
-
const parsedBody = parsedOutput.body;
|
|
2285
|
-
return throwDefaultError({
|
|
2286
|
-
output,
|
|
2287
|
-
parsedBody: parsedBody.Error,
|
|
2288
|
-
errorCode
|
|
2289
|
-
});
|
|
2290
|
-
}
|
|
2291
|
-
}, "de_DescribeMetricCollectionTypesCommandError");
|
|
2292
1613
|
var de_DescribeNotificationConfigurationsCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2293
1614
|
if (output.statusCode >= 300) {
|
|
2294
|
-
return
|
|
1615
|
+
return de_CommandError(output, context);
|
|
2295
1616
|
}
|
|
2296
1617
|
const data = await parseBody(output.body, context);
|
|
2297
1618
|
let contents = {};
|
|
@@ -2302,31 +1623,9 @@ var de_DescribeNotificationConfigurationsCommand = /* @__PURE__ */ __name(async
|
|
|
2302
1623
|
};
|
|
2303
1624
|
return response;
|
|
2304
1625
|
}, "de_DescribeNotificationConfigurationsCommand");
|
|
2305
|
-
var de_DescribeNotificationConfigurationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2306
|
-
const parsedOutput = {
|
|
2307
|
-
...output,
|
|
2308
|
-
body: await parseErrorBody(output.body, context)
|
|
2309
|
-
};
|
|
2310
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2311
|
-
switch (errorCode) {
|
|
2312
|
-
case "InvalidNextToken":
|
|
2313
|
-
case "com.amazonaws.autoscaling#InvalidNextToken":
|
|
2314
|
-
throw await de_InvalidNextTokenRes(parsedOutput, context);
|
|
2315
|
-
case "ResourceContention":
|
|
2316
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2317
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2318
|
-
default:
|
|
2319
|
-
const parsedBody = parsedOutput.body;
|
|
2320
|
-
return throwDefaultError({
|
|
2321
|
-
output,
|
|
2322
|
-
parsedBody: parsedBody.Error,
|
|
2323
|
-
errorCode
|
|
2324
|
-
});
|
|
2325
|
-
}
|
|
2326
|
-
}, "de_DescribeNotificationConfigurationsCommandError");
|
|
2327
1626
|
var de_DescribePoliciesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2328
1627
|
if (output.statusCode >= 300) {
|
|
2329
|
-
return
|
|
1628
|
+
return de_CommandError(output, context);
|
|
2330
1629
|
}
|
|
2331
1630
|
const data = await parseBody(output.body, context);
|
|
2332
1631
|
let contents = {};
|
|
@@ -2337,34 +1636,9 @@ var de_DescribePoliciesCommand = /* @__PURE__ */ __name(async (output, context)
|
|
|
2337
1636
|
};
|
|
2338
1637
|
return response;
|
|
2339
1638
|
}, "de_DescribePoliciesCommand");
|
|
2340
|
-
var de_DescribePoliciesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2341
|
-
const parsedOutput = {
|
|
2342
|
-
...output,
|
|
2343
|
-
body: await parseErrorBody(output.body, context)
|
|
2344
|
-
};
|
|
2345
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2346
|
-
switch (errorCode) {
|
|
2347
|
-
case "InvalidNextToken":
|
|
2348
|
-
case "com.amazonaws.autoscaling#InvalidNextToken":
|
|
2349
|
-
throw await de_InvalidNextTokenRes(parsedOutput, context);
|
|
2350
|
-
case "ResourceContention":
|
|
2351
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2352
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2353
|
-
case "ServiceLinkedRoleFailure":
|
|
2354
|
-
case "com.amazonaws.autoscaling#ServiceLinkedRoleFailure":
|
|
2355
|
-
throw await de_ServiceLinkedRoleFailureRes(parsedOutput, context);
|
|
2356
|
-
default:
|
|
2357
|
-
const parsedBody = parsedOutput.body;
|
|
2358
|
-
return throwDefaultError({
|
|
2359
|
-
output,
|
|
2360
|
-
parsedBody: parsedBody.Error,
|
|
2361
|
-
errorCode
|
|
2362
|
-
});
|
|
2363
|
-
}
|
|
2364
|
-
}, "de_DescribePoliciesCommandError");
|
|
2365
1639
|
var de_DescribeScalingActivitiesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2366
1640
|
if (output.statusCode >= 300) {
|
|
2367
|
-
return
|
|
1641
|
+
return de_CommandError(output, context);
|
|
2368
1642
|
}
|
|
2369
1643
|
const data = await parseBody(output.body, context);
|
|
2370
1644
|
let contents = {};
|
|
@@ -2375,31 +1649,9 @@ var de_DescribeScalingActivitiesCommand = /* @__PURE__ */ __name(async (output,
|
|
|
2375
1649
|
};
|
|
2376
1650
|
return response;
|
|
2377
1651
|
}, "de_DescribeScalingActivitiesCommand");
|
|
2378
|
-
var de_DescribeScalingActivitiesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2379
|
-
const parsedOutput = {
|
|
2380
|
-
...output,
|
|
2381
|
-
body: await parseErrorBody(output.body, context)
|
|
2382
|
-
};
|
|
2383
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2384
|
-
switch (errorCode) {
|
|
2385
|
-
case "InvalidNextToken":
|
|
2386
|
-
case "com.amazonaws.autoscaling#InvalidNextToken":
|
|
2387
|
-
throw await de_InvalidNextTokenRes(parsedOutput, context);
|
|
2388
|
-
case "ResourceContention":
|
|
2389
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2390
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2391
|
-
default:
|
|
2392
|
-
const parsedBody = parsedOutput.body;
|
|
2393
|
-
return throwDefaultError({
|
|
2394
|
-
output,
|
|
2395
|
-
parsedBody: parsedBody.Error,
|
|
2396
|
-
errorCode
|
|
2397
|
-
});
|
|
2398
|
-
}
|
|
2399
|
-
}, "de_DescribeScalingActivitiesCommandError");
|
|
2400
1652
|
var de_DescribeScalingProcessTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2401
1653
|
if (output.statusCode >= 300) {
|
|
2402
|
-
return
|
|
1654
|
+
return de_CommandError(output, context);
|
|
2403
1655
|
}
|
|
2404
1656
|
const data = await parseBody(output.body, context);
|
|
2405
1657
|
let contents = {};
|
|
@@ -2410,28 +1662,9 @@ var de_DescribeScalingProcessTypesCommand = /* @__PURE__ */ __name(async (output
|
|
|
2410
1662
|
};
|
|
2411
1663
|
return response;
|
|
2412
1664
|
}, "de_DescribeScalingProcessTypesCommand");
|
|
2413
|
-
var de_DescribeScalingProcessTypesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2414
|
-
const parsedOutput = {
|
|
2415
|
-
...output,
|
|
2416
|
-
body: await parseErrorBody(output.body, context)
|
|
2417
|
-
};
|
|
2418
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2419
|
-
switch (errorCode) {
|
|
2420
|
-
case "ResourceContention":
|
|
2421
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2422
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2423
|
-
default:
|
|
2424
|
-
const parsedBody = parsedOutput.body;
|
|
2425
|
-
return throwDefaultError({
|
|
2426
|
-
output,
|
|
2427
|
-
parsedBody: parsedBody.Error,
|
|
2428
|
-
errorCode
|
|
2429
|
-
});
|
|
2430
|
-
}
|
|
2431
|
-
}, "de_DescribeScalingProcessTypesCommandError");
|
|
2432
1665
|
var de_DescribeScheduledActionsCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2433
1666
|
if (output.statusCode >= 300) {
|
|
2434
|
-
return
|
|
1667
|
+
return de_CommandError(output, context);
|
|
2435
1668
|
}
|
|
2436
1669
|
const data = await parseBody(output.body, context);
|
|
2437
1670
|
let contents = {};
|
|
@@ -2442,31 +1675,9 @@ var de_DescribeScheduledActionsCommand = /* @__PURE__ */ __name(async (output, c
|
|
|
2442
1675
|
};
|
|
2443
1676
|
return response;
|
|
2444
1677
|
}, "de_DescribeScheduledActionsCommand");
|
|
2445
|
-
var de_DescribeScheduledActionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2446
|
-
const parsedOutput = {
|
|
2447
|
-
...output,
|
|
2448
|
-
body: await parseErrorBody(output.body, context)
|
|
2449
|
-
};
|
|
2450
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2451
|
-
switch (errorCode) {
|
|
2452
|
-
case "InvalidNextToken":
|
|
2453
|
-
case "com.amazonaws.autoscaling#InvalidNextToken":
|
|
2454
|
-
throw await de_InvalidNextTokenRes(parsedOutput, context);
|
|
2455
|
-
case "ResourceContention":
|
|
2456
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2457
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2458
|
-
default:
|
|
2459
|
-
const parsedBody = parsedOutput.body;
|
|
2460
|
-
return throwDefaultError({
|
|
2461
|
-
output,
|
|
2462
|
-
parsedBody: parsedBody.Error,
|
|
2463
|
-
errorCode
|
|
2464
|
-
});
|
|
2465
|
-
}
|
|
2466
|
-
}, "de_DescribeScheduledActionsCommandError");
|
|
2467
1678
|
var de_DescribeTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2468
1679
|
if (output.statusCode >= 300) {
|
|
2469
|
-
return
|
|
1680
|
+
return de_CommandError(output, context);
|
|
2470
1681
|
}
|
|
2471
1682
|
const data = await parseBody(output.body, context);
|
|
2472
1683
|
let contents = {};
|
|
@@ -2477,31 +1688,9 @@ var de_DescribeTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
|
2477
1688
|
};
|
|
2478
1689
|
return response;
|
|
2479
1690
|
}, "de_DescribeTagsCommand");
|
|
2480
|
-
var de_DescribeTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2481
|
-
const parsedOutput = {
|
|
2482
|
-
...output,
|
|
2483
|
-
body: await parseErrorBody(output.body, context)
|
|
2484
|
-
};
|
|
2485
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2486
|
-
switch (errorCode) {
|
|
2487
|
-
case "InvalidNextToken":
|
|
2488
|
-
case "com.amazonaws.autoscaling#InvalidNextToken":
|
|
2489
|
-
throw await de_InvalidNextTokenRes(parsedOutput, context);
|
|
2490
|
-
case "ResourceContention":
|
|
2491
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2492
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2493
|
-
default:
|
|
2494
|
-
const parsedBody = parsedOutput.body;
|
|
2495
|
-
return throwDefaultError({
|
|
2496
|
-
output,
|
|
2497
|
-
parsedBody: parsedBody.Error,
|
|
2498
|
-
errorCode
|
|
2499
|
-
});
|
|
2500
|
-
}
|
|
2501
|
-
}, "de_DescribeTagsCommandError");
|
|
2502
1691
|
var de_DescribeTerminationPolicyTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2503
1692
|
if (output.statusCode >= 300) {
|
|
2504
|
-
return
|
|
1693
|
+
return de_CommandError(output, context);
|
|
2505
1694
|
}
|
|
2506
1695
|
const data = await parseBody(output.body, context);
|
|
2507
1696
|
let contents = {};
|
|
@@ -2512,28 +1701,9 @@ var de_DescribeTerminationPolicyTypesCommand = /* @__PURE__ */ __name(async (out
|
|
|
2512
1701
|
};
|
|
2513
1702
|
return response;
|
|
2514
1703
|
}, "de_DescribeTerminationPolicyTypesCommand");
|
|
2515
|
-
var de_DescribeTerminationPolicyTypesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2516
|
-
const parsedOutput = {
|
|
2517
|
-
...output,
|
|
2518
|
-
body: await parseErrorBody(output.body, context)
|
|
2519
|
-
};
|
|
2520
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2521
|
-
switch (errorCode) {
|
|
2522
|
-
case "ResourceContention":
|
|
2523
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2524
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2525
|
-
default:
|
|
2526
|
-
const parsedBody = parsedOutput.body;
|
|
2527
|
-
return throwDefaultError({
|
|
2528
|
-
output,
|
|
2529
|
-
parsedBody: parsedBody.Error,
|
|
2530
|
-
errorCode
|
|
2531
|
-
});
|
|
2532
|
-
}
|
|
2533
|
-
}, "de_DescribeTerminationPolicyTypesCommandError");
|
|
2534
1704
|
var de_DescribeTrafficSourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2535
1705
|
if (output.statusCode >= 300) {
|
|
2536
|
-
return
|
|
1706
|
+
return de_CommandError(output, context);
|
|
2537
1707
|
}
|
|
2538
1708
|
const data = await parseBody(output.body, context);
|
|
2539
1709
|
let contents = {};
|
|
@@ -2541,72 +1711,25 @@ var de_DescribeTrafficSourcesCommand = /* @__PURE__ */ __name(async (output, con
|
|
|
2541
1711
|
const response = {
|
|
2542
1712
|
$metadata: deserializeMetadata(output),
|
|
2543
1713
|
...contents
|
|
2544
|
-
};
|
|
2545
|
-
return response;
|
|
2546
|
-
}, "de_DescribeTrafficSourcesCommand");
|
|
2547
|
-
var
|
|
2548
|
-
|
|
2549
|
-
|
|
2550
|
-
body: await parseErrorBody(output.body, context)
|
|
2551
|
-
};
|
|
2552
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2553
|
-
switch (errorCode) {
|
|
2554
|
-
case "InvalidNextToken":
|
|
2555
|
-
case "com.amazonaws.autoscaling#InvalidNextToken":
|
|
2556
|
-
throw await de_InvalidNextTokenRes(parsedOutput, context);
|
|
2557
|
-
case "ResourceContention":
|
|
2558
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2559
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2560
|
-
default:
|
|
2561
|
-
const parsedBody = parsedOutput.body;
|
|
2562
|
-
return throwDefaultError({
|
|
2563
|
-
output,
|
|
2564
|
-
parsedBody: parsedBody.Error,
|
|
2565
|
-
errorCode
|
|
2566
|
-
});
|
|
2567
|
-
}
|
|
2568
|
-
}, "de_DescribeTrafficSourcesCommandError");
|
|
2569
|
-
var de_DescribeWarmPoolCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2570
|
-
if (output.statusCode >= 300) {
|
|
2571
|
-
return de_DescribeWarmPoolCommandError(output, context);
|
|
2572
|
-
}
|
|
2573
|
-
const data = await parseBody(output.body, context);
|
|
2574
|
-
let contents = {};
|
|
2575
|
-
contents = de_DescribeWarmPoolAnswer(data.DescribeWarmPoolResult, context);
|
|
2576
|
-
const response = {
|
|
2577
|
-
$metadata: deserializeMetadata(output),
|
|
2578
|
-
...contents
|
|
2579
|
-
};
|
|
2580
|
-
return response;
|
|
2581
|
-
}, "de_DescribeWarmPoolCommand");
|
|
2582
|
-
var de_DescribeWarmPoolCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2583
|
-
const parsedOutput = {
|
|
2584
|
-
...output,
|
|
2585
|
-
body: await parseErrorBody(output.body, context)
|
|
2586
|
-
};
|
|
2587
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2588
|
-
switch (errorCode) {
|
|
2589
|
-
case "InvalidNextToken":
|
|
2590
|
-
case "com.amazonaws.autoscaling#InvalidNextToken":
|
|
2591
|
-
throw await de_InvalidNextTokenRes(parsedOutput, context);
|
|
2592
|
-
case "LimitExceeded":
|
|
2593
|
-
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
2594
|
-
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
2595
|
-
case "ResourceContention":
|
|
2596
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2597
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2598
|
-
default:
|
|
2599
|
-
const parsedBody = parsedOutput.body;
|
|
2600
|
-
return throwDefaultError({
|
|
2601
|
-
output,
|
|
2602
|
-
parsedBody: parsedBody.Error,
|
|
2603
|
-
errorCode
|
|
2604
|
-
});
|
|
1714
|
+
};
|
|
1715
|
+
return response;
|
|
1716
|
+
}, "de_DescribeTrafficSourcesCommand");
|
|
1717
|
+
var de_DescribeWarmPoolCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
1718
|
+
if (output.statusCode >= 300) {
|
|
1719
|
+
return de_CommandError(output, context);
|
|
2605
1720
|
}
|
|
2606
|
-
|
|
1721
|
+
const data = await parseBody(output.body, context);
|
|
1722
|
+
let contents = {};
|
|
1723
|
+
contents = de_DescribeWarmPoolAnswer(data.DescribeWarmPoolResult, context);
|
|
1724
|
+
const response = {
|
|
1725
|
+
$metadata: deserializeMetadata(output),
|
|
1726
|
+
...contents
|
|
1727
|
+
};
|
|
1728
|
+
return response;
|
|
1729
|
+
}, "de_DescribeWarmPoolCommand");
|
|
2607
1730
|
var de_DetachInstancesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2608
1731
|
if (output.statusCode >= 300) {
|
|
2609
|
-
return
|
|
1732
|
+
return de_CommandError(output, context);
|
|
2610
1733
|
}
|
|
2611
1734
|
const data = await parseBody(output.body, context);
|
|
2612
1735
|
let contents = {};
|
|
@@ -2617,28 +1740,9 @@ var de_DetachInstancesCommand = /* @__PURE__ */ __name(async (output, context) =
|
|
|
2617
1740
|
};
|
|
2618
1741
|
return response;
|
|
2619
1742
|
}, "de_DetachInstancesCommand");
|
|
2620
|
-
var de_DetachInstancesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2621
|
-
const parsedOutput = {
|
|
2622
|
-
...output,
|
|
2623
|
-
body: await parseErrorBody(output.body, context)
|
|
2624
|
-
};
|
|
2625
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2626
|
-
switch (errorCode) {
|
|
2627
|
-
case "ResourceContention":
|
|
2628
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2629
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2630
|
-
default:
|
|
2631
|
-
const parsedBody = parsedOutput.body;
|
|
2632
|
-
return throwDefaultError({
|
|
2633
|
-
output,
|
|
2634
|
-
parsedBody: parsedBody.Error,
|
|
2635
|
-
errorCode
|
|
2636
|
-
});
|
|
2637
|
-
}
|
|
2638
|
-
}, "de_DetachInstancesCommandError");
|
|
2639
1743
|
var de_DetachLoadBalancersCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2640
1744
|
if (output.statusCode >= 300) {
|
|
2641
|
-
return
|
|
1745
|
+
return de_CommandError(output, context);
|
|
2642
1746
|
}
|
|
2643
1747
|
const data = await parseBody(output.body, context);
|
|
2644
1748
|
let contents = {};
|
|
@@ -2649,28 +1753,9 @@ var de_DetachLoadBalancersCommand = /* @__PURE__ */ __name(async (output, contex
|
|
|
2649
1753
|
};
|
|
2650
1754
|
return response;
|
|
2651
1755
|
}, "de_DetachLoadBalancersCommand");
|
|
2652
|
-
var de_DetachLoadBalancersCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2653
|
-
const parsedOutput = {
|
|
2654
|
-
...output,
|
|
2655
|
-
body: await parseErrorBody(output.body, context)
|
|
2656
|
-
};
|
|
2657
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2658
|
-
switch (errorCode) {
|
|
2659
|
-
case "ResourceContention":
|
|
2660
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2661
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2662
|
-
default:
|
|
2663
|
-
const parsedBody = parsedOutput.body;
|
|
2664
|
-
return throwDefaultError({
|
|
2665
|
-
output,
|
|
2666
|
-
parsedBody: parsedBody.Error,
|
|
2667
|
-
errorCode
|
|
2668
|
-
});
|
|
2669
|
-
}
|
|
2670
|
-
}, "de_DetachLoadBalancersCommandError");
|
|
2671
1756
|
var de_DetachLoadBalancerTargetGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2672
1757
|
if (output.statusCode >= 300) {
|
|
2673
|
-
return
|
|
1758
|
+
return de_CommandError(output, context);
|
|
2674
1759
|
}
|
|
2675
1760
|
const data = await parseBody(output.body, context);
|
|
2676
1761
|
let contents = {};
|
|
@@ -2681,28 +1766,9 @@ var de_DetachLoadBalancerTargetGroupsCommand = /* @__PURE__ */ __name(async (out
|
|
|
2681
1766
|
};
|
|
2682
1767
|
return response;
|
|
2683
1768
|
}, "de_DetachLoadBalancerTargetGroupsCommand");
|
|
2684
|
-
var de_DetachLoadBalancerTargetGroupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2685
|
-
const parsedOutput = {
|
|
2686
|
-
...output,
|
|
2687
|
-
body: await parseErrorBody(output.body, context)
|
|
2688
|
-
};
|
|
2689
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2690
|
-
switch (errorCode) {
|
|
2691
|
-
case "ResourceContention":
|
|
2692
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2693
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2694
|
-
default:
|
|
2695
|
-
const parsedBody = parsedOutput.body;
|
|
2696
|
-
return throwDefaultError({
|
|
2697
|
-
output,
|
|
2698
|
-
parsedBody: parsedBody.Error,
|
|
2699
|
-
errorCode
|
|
2700
|
-
});
|
|
2701
|
-
}
|
|
2702
|
-
}, "de_DetachLoadBalancerTargetGroupsCommandError");
|
|
2703
1769
|
var de_DetachTrafficSourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2704
1770
|
if (output.statusCode >= 300) {
|
|
2705
|
-
return
|
|
1771
|
+
return de_CommandError(output, context);
|
|
2706
1772
|
}
|
|
2707
1773
|
const data = await parseBody(output.body, context);
|
|
2708
1774
|
let contents = {};
|
|
@@ -2713,28 +1779,9 @@ var de_DetachTrafficSourcesCommand = /* @__PURE__ */ __name(async (output, conte
|
|
|
2713
1779
|
};
|
|
2714
1780
|
return response;
|
|
2715
1781
|
}, "de_DetachTrafficSourcesCommand");
|
|
2716
|
-
var de_DetachTrafficSourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2717
|
-
const parsedOutput = {
|
|
2718
|
-
...output,
|
|
2719
|
-
body: await parseErrorBody(output.body, context)
|
|
2720
|
-
};
|
|
2721
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2722
|
-
switch (errorCode) {
|
|
2723
|
-
case "ResourceContention":
|
|
2724
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2725
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2726
|
-
default:
|
|
2727
|
-
const parsedBody = parsedOutput.body;
|
|
2728
|
-
return throwDefaultError({
|
|
2729
|
-
output,
|
|
2730
|
-
parsedBody: parsedBody.Error,
|
|
2731
|
-
errorCode
|
|
2732
|
-
});
|
|
2733
|
-
}
|
|
2734
|
-
}, "de_DetachTrafficSourcesCommandError");
|
|
2735
1782
|
var de_DisableMetricsCollectionCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2736
1783
|
if (output.statusCode >= 300) {
|
|
2737
|
-
return
|
|
1784
|
+
return de_CommandError(output, context);
|
|
2738
1785
|
}
|
|
2739
1786
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
2740
1787
|
const response = {
|
|
@@ -2742,28 +1789,9 @@ var de_DisableMetricsCollectionCommand = /* @__PURE__ */ __name(async (output, c
|
|
|
2742
1789
|
};
|
|
2743
1790
|
return response;
|
|
2744
1791
|
}, "de_DisableMetricsCollectionCommand");
|
|
2745
|
-
var de_DisableMetricsCollectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2746
|
-
const parsedOutput = {
|
|
2747
|
-
...output,
|
|
2748
|
-
body: await parseErrorBody(output.body, context)
|
|
2749
|
-
};
|
|
2750
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2751
|
-
switch (errorCode) {
|
|
2752
|
-
case "ResourceContention":
|
|
2753
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2754
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2755
|
-
default:
|
|
2756
|
-
const parsedBody = parsedOutput.body;
|
|
2757
|
-
return throwDefaultError({
|
|
2758
|
-
output,
|
|
2759
|
-
parsedBody: parsedBody.Error,
|
|
2760
|
-
errorCode
|
|
2761
|
-
});
|
|
2762
|
-
}
|
|
2763
|
-
}, "de_DisableMetricsCollectionCommandError");
|
|
2764
1792
|
var de_EnableMetricsCollectionCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2765
1793
|
if (output.statusCode >= 300) {
|
|
2766
|
-
return
|
|
1794
|
+
return de_CommandError(output, context);
|
|
2767
1795
|
}
|
|
2768
1796
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
2769
1797
|
const response = {
|
|
@@ -2771,28 +1799,9 @@ var de_EnableMetricsCollectionCommand = /* @__PURE__ */ __name(async (output, co
|
|
|
2771
1799
|
};
|
|
2772
1800
|
return response;
|
|
2773
1801
|
}, "de_EnableMetricsCollectionCommand");
|
|
2774
|
-
var de_EnableMetricsCollectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2775
|
-
const parsedOutput = {
|
|
2776
|
-
...output,
|
|
2777
|
-
body: await parseErrorBody(output.body, context)
|
|
2778
|
-
};
|
|
2779
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2780
|
-
switch (errorCode) {
|
|
2781
|
-
case "ResourceContention":
|
|
2782
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2783
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2784
|
-
default:
|
|
2785
|
-
const parsedBody = parsedOutput.body;
|
|
2786
|
-
return throwDefaultError({
|
|
2787
|
-
output,
|
|
2788
|
-
parsedBody: parsedBody.Error,
|
|
2789
|
-
errorCode
|
|
2790
|
-
});
|
|
2791
|
-
}
|
|
2792
|
-
}, "de_EnableMetricsCollectionCommandError");
|
|
2793
1802
|
var de_EnterStandbyCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2794
1803
|
if (output.statusCode >= 300) {
|
|
2795
|
-
return
|
|
1804
|
+
return de_CommandError(output, context);
|
|
2796
1805
|
}
|
|
2797
1806
|
const data = await parseBody(output.body, context);
|
|
2798
1807
|
let contents = {};
|
|
@@ -2803,28 +1812,9 @@ var de_EnterStandbyCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
|
2803
1812
|
};
|
|
2804
1813
|
return response;
|
|
2805
1814
|
}, "de_EnterStandbyCommand");
|
|
2806
|
-
var de_EnterStandbyCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2807
|
-
const parsedOutput = {
|
|
2808
|
-
...output,
|
|
2809
|
-
body: await parseErrorBody(output.body, context)
|
|
2810
|
-
};
|
|
2811
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2812
|
-
switch (errorCode) {
|
|
2813
|
-
case "ResourceContention":
|
|
2814
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2815
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2816
|
-
default:
|
|
2817
|
-
const parsedBody = parsedOutput.body;
|
|
2818
|
-
return throwDefaultError({
|
|
2819
|
-
output,
|
|
2820
|
-
parsedBody: parsedBody.Error,
|
|
2821
|
-
errorCode
|
|
2822
|
-
});
|
|
2823
|
-
}
|
|
2824
|
-
}, "de_EnterStandbyCommandError");
|
|
2825
1815
|
var de_ExecutePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2826
1816
|
if (output.statusCode >= 300) {
|
|
2827
|
-
return
|
|
1817
|
+
return de_CommandError(output, context);
|
|
2828
1818
|
}
|
|
2829
1819
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
2830
1820
|
const response = {
|
|
@@ -2832,31 +1822,9 @@ var de_ExecutePolicyCommand = /* @__PURE__ */ __name(async (output, context) =>
|
|
|
2832
1822
|
};
|
|
2833
1823
|
return response;
|
|
2834
1824
|
}, "de_ExecutePolicyCommand");
|
|
2835
|
-
var de_ExecutePolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2836
|
-
const parsedOutput = {
|
|
2837
|
-
...output,
|
|
2838
|
-
body: await parseErrorBody(output.body, context)
|
|
2839
|
-
};
|
|
2840
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2841
|
-
switch (errorCode) {
|
|
2842
|
-
case "ResourceContention":
|
|
2843
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2844
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2845
|
-
case "ScalingActivityInProgress":
|
|
2846
|
-
case "com.amazonaws.autoscaling#ScalingActivityInProgressFault":
|
|
2847
|
-
throw await de_ScalingActivityInProgressFaultRes(parsedOutput, context);
|
|
2848
|
-
default:
|
|
2849
|
-
const parsedBody = parsedOutput.body;
|
|
2850
|
-
return throwDefaultError({
|
|
2851
|
-
output,
|
|
2852
|
-
parsedBody: parsedBody.Error,
|
|
2853
|
-
errorCode
|
|
2854
|
-
});
|
|
2855
|
-
}
|
|
2856
|
-
}, "de_ExecutePolicyCommandError");
|
|
2857
1825
|
var de_ExitStandbyCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2858
1826
|
if (output.statusCode >= 300) {
|
|
2859
|
-
return
|
|
1827
|
+
return de_CommandError(output, context);
|
|
2860
1828
|
}
|
|
2861
1829
|
const data = await parseBody(output.body, context);
|
|
2862
1830
|
let contents = {};
|
|
@@ -2867,28 +1835,9 @@ var de_ExitStandbyCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
|
2867
1835
|
};
|
|
2868
1836
|
return response;
|
|
2869
1837
|
}, "de_ExitStandbyCommand");
|
|
2870
|
-
var de_ExitStandbyCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2871
|
-
const parsedOutput = {
|
|
2872
|
-
...output,
|
|
2873
|
-
body: await parseErrorBody(output.body, context)
|
|
2874
|
-
};
|
|
2875
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2876
|
-
switch (errorCode) {
|
|
2877
|
-
case "ResourceContention":
|
|
2878
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2879
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2880
|
-
default:
|
|
2881
|
-
const parsedBody = parsedOutput.body;
|
|
2882
|
-
return throwDefaultError({
|
|
2883
|
-
output,
|
|
2884
|
-
parsedBody: parsedBody.Error,
|
|
2885
|
-
errorCode
|
|
2886
|
-
});
|
|
2887
|
-
}
|
|
2888
|
-
}, "de_ExitStandbyCommandError");
|
|
2889
1838
|
var de_GetPredictiveScalingForecastCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2890
1839
|
if (output.statusCode >= 300) {
|
|
2891
|
-
return
|
|
1840
|
+
return de_CommandError(output, context);
|
|
2892
1841
|
}
|
|
2893
1842
|
const data = await parseBody(output.body, context);
|
|
2894
1843
|
let contents = {};
|
|
@@ -2899,28 +1848,9 @@ var de_GetPredictiveScalingForecastCommand = /* @__PURE__ */ __name(async (outpu
|
|
|
2899
1848
|
};
|
|
2900
1849
|
return response;
|
|
2901
1850
|
}, "de_GetPredictiveScalingForecastCommand");
|
|
2902
|
-
var de_GetPredictiveScalingForecastCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2903
|
-
const parsedOutput = {
|
|
2904
|
-
...output,
|
|
2905
|
-
body: await parseErrorBody(output.body, context)
|
|
2906
|
-
};
|
|
2907
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2908
|
-
switch (errorCode) {
|
|
2909
|
-
case "ResourceContention":
|
|
2910
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2911
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2912
|
-
default:
|
|
2913
|
-
const parsedBody = parsedOutput.body;
|
|
2914
|
-
return throwDefaultError({
|
|
2915
|
-
output,
|
|
2916
|
-
parsedBody: parsedBody.Error,
|
|
2917
|
-
errorCode
|
|
2918
|
-
});
|
|
2919
|
-
}
|
|
2920
|
-
}, "de_GetPredictiveScalingForecastCommandError");
|
|
2921
1851
|
var de_PutLifecycleHookCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2922
1852
|
if (output.statusCode >= 300) {
|
|
2923
|
-
return
|
|
1853
|
+
return de_CommandError(output, context);
|
|
2924
1854
|
}
|
|
2925
1855
|
const data = await parseBody(output.body, context);
|
|
2926
1856
|
let contents = {};
|
|
@@ -2931,31 +1861,9 @@ var de_PutLifecycleHookCommand = /* @__PURE__ */ __name(async (output, context)
|
|
|
2931
1861
|
};
|
|
2932
1862
|
return response;
|
|
2933
1863
|
}, "de_PutLifecycleHookCommand");
|
|
2934
|
-
var de_PutLifecycleHookCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2935
|
-
const parsedOutput = {
|
|
2936
|
-
...output,
|
|
2937
|
-
body: await parseErrorBody(output.body, context)
|
|
2938
|
-
};
|
|
2939
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2940
|
-
switch (errorCode) {
|
|
2941
|
-
case "LimitExceeded":
|
|
2942
|
-
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
2943
|
-
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
2944
|
-
case "ResourceContention":
|
|
2945
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2946
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2947
|
-
default:
|
|
2948
|
-
const parsedBody = parsedOutput.body;
|
|
2949
|
-
return throwDefaultError({
|
|
2950
|
-
output,
|
|
2951
|
-
parsedBody: parsedBody.Error,
|
|
2952
|
-
errorCode
|
|
2953
|
-
});
|
|
2954
|
-
}
|
|
2955
|
-
}, "de_PutLifecycleHookCommandError");
|
|
2956
1864
|
var de_PutNotificationConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2957
1865
|
if (output.statusCode >= 300) {
|
|
2958
|
-
return
|
|
1866
|
+
return de_CommandError(output, context);
|
|
2959
1867
|
}
|
|
2960
1868
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
2961
1869
|
const response = {
|
|
@@ -2963,34 +1871,9 @@ var de_PutNotificationConfigurationCommand = /* @__PURE__ */ __name(async (outpu
|
|
|
2963
1871
|
};
|
|
2964
1872
|
return response;
|
|
2965
1873
|
}, "de_PutNotificationConfigurationCommand");
|
|
2966
|
-
var de_PutNotificationConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
2967
|
-
const parsedOutput = {
|
|
2968
|
-
...output,
|
|
2969
|
-
body: await parseErrorBody(output.body, context)
|
|
2970
|
-
};
|
|
2971
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
2972
|
-
switch (errorCode) {
|
|
2973
|
-
case "LimitExceeded":
|
|
2974
|
-
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
2975
|
-
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
2976
|
-
case "ResourceContention":
|
|
2977
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
2978
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
2979
|
-
case "ServiceLinkedRoleFailure":
|
|
2980
|
-
case "com.amazonaws.autoscaling#ServiceLinkedRoleFailure":
|
|
2981
|
-
throw await de_ServiceLinkedRoleFailureRes(parsedOutput, context);
|
|
2982
|
-
default:
|
|
2983
|
-
const parsedBody = parsedOutput.body;
|
|
2984
|
-
return throwDefaultError({
|
|
2985
|
-
output,
|
|
2986
|
-
parsedBody: parsedBody.Error,
|
|
2987
|
-
errorCode
|
|
2988
|
-
});
|
|
2989
|
-
}
|
|
2990
|
-
}, "de_PutNotificationConfigurationCommandError");
|
|
2991
1874
|
var de_PutScalingPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
2992
1875
|
if (output.statusCode >= 300) {
|
|
2993
|
-
return
|
|
1876
|
+
return de_CommandError(output, context);
|
|
2994
1877
|
}
|
|
2995
1878
|
const data = await parseBody(output.body, context);
|
|
2996
1879
|
let contents = {};
|
|
@@ -2998,37 +1881,12 @@ var de_PutScalingPolicyCommand = /* @__PURE__ */ __name(async (output, context)
|
|
|
2998
1881
|
const response = {
|
|
2999
1882
|
$metadata: deserializeMetadata(output),
|
|
3000
1883
|
...contents
|
|
3001
|
-
};
|
|
3002
|
-
return response;
|
|
3003
|
-
}, "de_PutScalingPolicyCommand");
|
|
3004
|
-
var de_PutScalingPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
3005
|
-
const parsedOutput = {
|
|
3006
|
-
...output,
|
|
3007
|
-
body: await parseErrorBody(output.body, context)
|
|
3008
|
-
};
|
|
3009
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
3010
|
-
switch (errorCode) {
|
|
3011
|
-
case "LimitExceeded":
|
|
3012
|
-
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
3013
|
-
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
3014
|
-
case "ResourceContention":
|
|
3015
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
3016
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
3017
|
-
case "ServiceLinkedRoleFailure":
|
|
3018
|
-
case "com.amazonaws.autoscaling#ServiceLinkedRoleFailure":
|
|
3019
|
-
throw await de_ServiceLinkedRoleFailureRes(parsedOutput, context);
|
|
3020
|
-
default:
|
|
3021
|
-
const parsedBody = parsedOutput.body;
|
|
3022
|
-
return throwDefaultError({
|
|
3023
|
-
output,
|
|
3024
|
-
parsedBody: parsedBody.Error,
|
|
3025
|
-
errorCode
|
|
3026
|
-
});
|
|
3027
|
-
}
|
|
3028
|
-
}, "de_PutScalingPolicyCommandError");
|
|
1884
|
+
};
|
|
1885
|
+
return response;
|
|
1886
|
+
}, "de_PutScalingPolicyCommand");
|
|
3029
1887
|
var de_PutScheduledUpdateGroupActionCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
3030
1888
|
if (output.statusCode >= 300) {
|
|
3031
|
-
return
|
|
1889
|
+
return de_CommandError(output, context);
|
|
3032
1890
|
}
|
|
3033
1891
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
3034
1892
|
const response = {
|
|
@@ -3036,34 +1894,9 @@ var de_PutScheduledUpdateGroupActionCommand = /* @__PURE__ */ __name(async (outp
|
|
|
3036
1894
|
};
|
|
3037
1895
|
return response;
|
|
3038
1896
|
}, "de_PutScheduledUpdateGroupActionCommand");
|
|
3039
|
-
var de_PutScheduledUpdateGroupActionCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
3040
|
-
const parsedOutput = {
|
|
3041
|
-
...output,
|
|
3042
|
-
body: await parseErrorBody(output.body, context)
|
|
3043
|
-
};
|
|
3044
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
3045
|
-
switch (errorCode) {
|
|
3046
|
-
case "AlreadyExists":
|
|
3047
|
-
case "com.amazonaws.autoscaling#AlreadyExistsFault":
|
|
3048
|
-
throw await de_AlreadyExistsFaultRes(parsedOutput, context);
|
|
3049
|
-
case "LimitExceeded":
|
|
3050
|
-
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
3051
|
-
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
3052
|
-
case "ResourceContention":
|
|
3053
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
3054
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
3055
|
-
default:
|
|
3056
|
-
const parsedBody = parsedOutput.body;
|
|
3057
|
-
return throwDefaultError({
|
|
3058
|
-
output,
|
|
3059
|
-
parsedBody: parsedBody.Error,
|
|
3060
|
-
errorCode
|
|
3061
|
-
});
|
|
3062
|
-
}
|
|
3063
|
-
}, "de_PutScheduledUpdateGroupActionCommandError");
|
|
3064
1897
|
var de_PutWarmPoolCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
3065
1898
|
if (output.statusCode >= 300) {
|
|
3066
|
-
return
|
|
1899
|
+
return de_CommandError(output, context);
|
|
3067
1900
|
}
|
|
3068
1901
|
const data = await parseBody(output.body, context);
|
|
3069
1902
|
let contents = {};
|
|
@@ -3074,31 +1907,9 @@ var de_PutWarmPoolCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
|
3074
1907
|
};
|
|
3075
1908
|
return response;
|
|
3076
1909
|
}, "de_PutWarmPoolCommand");
|
|
3077
|
-
var de_PutWarmPoolCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
3078
|
-
const parsedOutput = {
|
|
3079
|
-
...output,
|
|
3080
|
-
body: await parseErrorBody(output.body, context)
|
|
3081
|
-
};
|
|
3082
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
3083
|
-
switch (errorCode) {
|
|
3084
|
-
case "LimitExceeded":
|
|
3085
|
-
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
3086
|
-
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
3087
|
-
case "ResourceContention":
|
|
3088
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
3089
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
3090
|
-
default:
|
|
3091
|
-
const parsedBody = parsedOutput.body;
|
|
3092
|
-
return throwDefaultError({
|
|
3093
|
-
output,
|
|
3094
|
-
parsedBody: parsedBody.Error,
|
|
3095
|
-
errorCode
|
|
3096
|
-
});
|
|
3097
|
-
}
|
|
3098
|
-
}, "de_PutWarmPoolCommandError");
|
|
3099
1910
|
var de_RecordLifecycleActionHeartbeatCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
3100
1911
|
if (output.statusCode >= 300) {
|
|
3101
|
-
return
|
|
1912
|
+
return de_CommandError(output, context);
|
|
3102
1913
|
}
|
|
3103
1914
|
const data = await parseBody(output.body, context);
|
|
3104
1915
|
let contents = {};
|
|
@@ -3109,28 +1920,9 @@ var de_RecordLifecycleActionHeartbeatCommand = /* @__PURE__ */ __name(async (out
|
|
|
3109
1920
|
};
|
|
3110
1921
|
return response;
|
|
3111
1922
|
}, "de_RecordLifecycleActionHeartbeatCommand");
|
|
3112
|
-
var de_RecordLifecycleActionHeartbeatCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
3113
|
-
const parsedOutput = {
|
|
3114
|
-
...output,
|
|
3115
|
-
body: await parseErrorBody(output.body, context)
|
|
3116
|
-
};
|
|
3117
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
3118
|
-
switch (errorCode) {
|
|
3119
|
-
case "ResourceContention":
|
|
3120
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
3121
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
3122
|
-
default:
|
|
3123
|
-
const parsedBody = parsedOutput.body;
|
|
3124
|
-
return throwDefaultError({
|
|
3125
|
-
output,
|
|
3126
|
-
parsedBody: parsedBody.Error,
|
|
3127
|
-
errorCode
|
|
3128
|
-
});
|
|
3129
|
-
}
|
|
3130
|
-
}, "de_RecordLifecycleActionHeartbeatCommandError");
|
|
3131
1923
|
var de_ResumeProcessesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
3132
1924
|
if (output.statusCode >= 300) {
|
|
3133
|
-
return
|
|
1925
|
+
return de_CommandError(output, context);
|
|
3134
1926
|
}
|
|
3135
1927
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
3136
1928
|
const response = {
|
|
@@ -3138,31 +1930,9 @@ var de_ResumeProcessesCommand = /* @__PURE__ */ __name(async (output, context) =
|
|
|
3138
1930
|
};
|
|
3139
1931
|
return response;
|
|
3140
1932
|
}, "de_ResumeProcessesCommand");
|
|
3141
|
-
var de_ResumeProcessesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
3142
|
-
const parsedOutput = {
|
|
3143
|
-
...output,
|
|
3144
|
-
body: await parseErrorBody(output.body, context)
|
|
3145
|
-
};
|
|
3146
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
3147
|
-
switch (errorCode) {
|
|
3148
|
-
case "ResourceContention":
|
|
3149
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
3150
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
3151
|
-
case "ResourceInUse":
|
|
3152
|
-
case "com.amazonaws.autoscaling#ResourceInUseFault":
|
|
3153
|
-
throw await de_ResourceInUseFaultRes(parsedOutput, context);
|
|
3154
|
-
default:
|
|
3155
|
-
const parsedBody = parsedOutput.body;
|
|
3156
|
-
return throwDefaultError({
|
|
3157
|
-
output,
|
|
3158
|
-
parsedBody: parsedBody.Error,
|
|
3159
|
-
errorCode
|
|
3160
|
-
});
|
|
3161
|
-
}
|
|
3162
|
-
}, "de_ResumeProcessesCommandError");
|
|
3163
1933
|
var de_RollbackInstanceRefreshCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
3164
1934
|
if (output.statusCode >= 300) {
|
|
3165
|
-
return
|
|
1935
|
+
return de_CommandError(output, context);
|
|
3166
1936
|
}
|
|
3167
1937
|
const data = await parseBody(output.body, context);
|
|
3168
1938
|
let contents = {};
|
|
@@ -3173,37 +1943,9 @@ var de_RollbackInstanceRefreshCommand = /* @__PURE__ */ __name(async (output, co
|
|
|
3173
1943
|
};
|
|
3174
1944
|
return response;
|
|
3175
1945
|
}, "de_RollbackInstanceRefreshCommand");
|
|
3176
|
-
var de_RollbackInstanceRefreshCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
3177
|
-
const parsedOutput = {
|
|
3178
|
-
...output,
|
|
3179
|
-
body: await parseErrorBody(output.body, context)
|
|
3180
|
-
};
|
|
3181
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
3182
|
-
switch (errorCode) {
|
|
3183
|
-
case "ActiveInstanceRefreshNotFound":
|
|
3184
|
-
case "com.amazonaws.autoscaling#ActiveInstanceRefreshNotFoundFault":
|
|
3185
|
-
throw await de_ActiveInstanceRefreshNotFoundFaultRes(parsedOutput, context);
|
|
3186
|
-
case "IrreversibleInstanceRefresh":
|
|
3187
|
-
case "com.amazonaws.autoscaling#IrreversibleInstanceRefreshFault":
|
|
3188
|
-
throw await de_IrreversibleInstanceRefreshFaultRes(parsedOutput, context);
|
|
3189
|
-
case "LimitExceeded":
|
|
3190
|
-
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
3191
|
-
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
3192
|
-
case "ResourceContention":
|
|
3193
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
3194
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
3195
|
-
default:
|
|
3196
|
-
const parsedBody = parsedOutput.body;
|
|
3197
|
-
return throwDefaultError({
|
|
3198
|
-
output,
|
|
3199
|
-
parsedBody: parsedBody.Error,
|
|
3200
|
-
errorCode
|
|
3201
|
-
});
|
|
3202
|
-
}
|
|
3203
|
-
}, "de_RollbackInstanceRefreshCommandError");
|
|
3204
1946
|
var de_SetDesiredCapacityCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
3205
1947
|
if (output.statusCode >= 300) {
|
|
3206
|
-
return
|
|
1948
|
+
return de_CommandError(output, context);
|
|
3207
1949
|
}
|
|
3208
1950
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
3209
1951
|
const response = {
|
|
@@ -3211,31 +1953,9 @@ var de_SetDesiredCapacityCommand = /* @__PURE__ */ __name(async (output, context
|
|
|
3211
1953
|
};
|
|
3212
1954
|
return response;
|
|
3213
1955
|
}, "de_SetDesiredCapacityCommand");
|
|
3214
|
-
var de_SetDesiredCapacityCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
3215
|
-
const parsedOutput = {
|
|
3216
|
-
...output,
|
|
3217
|
-
body: await parseErrorBody(output.body, context)
|
|
3218
|
-
};
|
|
3219
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
3220
|
-
switch (errorCode) {
|
|
3221
|
-
case "ResourceContention":
|
|
3222
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
3223
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
3224
|
-
case "ScalingActivityInProgress":
|
|
3225
|
-
case "com.amazonaws.autoscaling#ScalingActivityInProgressFault":
|
|
3226
|
-
throw await de_ScalingActivityInProgressFaultRes(parsedOutput, context);
|
|
3227
|
-
default:
|
|
3228
|
-
const parsedBody = parsedOutput.body;
|
|
3229
|
-
return throwDefaultError({
|
|
3230
|
-
output,
|
|
3231
|
-
parsedBody: parsedBody.Error,
|
|
3232
|
-
errorCode
|
|
3233
|
-
});
|
|
3234
|
-
}
|
|
3235
|
-
}, "de_SetDesiredCapacityCommandError");
|
|
3236
1956
|
var de_SetInstanceHealthCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
3237
1957
|
if (output.statusCode >= 300) {
|
|
3238
|
-
return
|
|
1958
|
+
return de_CommandError(output, context);
|
|
3239
1959
|
}
|
|
3240
1960
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
3241
1961
|
const response = {
|
|
@@ -3243,28 +1963,9 @@ var de_SetInstanceHealthCommand = /* @__PURE__ */ __name(async (output, context)
|
|
|
3243
1963
|
};
|
|
3244
1964
|
return response;
|
|
3245
1965
|
}, "de_SetInstanceHealthCommand");
|
|
3246
|
-
var de_SetInstanceHealthCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
3247
|
-
const parsedOutput = {
|
|
3248
|
-
...output,
|
|
3249
|
-
body: await parseErrorBody(output.body, context)
|
|
3250
|
-
};
|
|
3251
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
3252
|
-
switch (errorCode) {
|
|
3253
|
-
case "ResourceContention":
|
|
3254
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
3255
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
3256
|
-
default:
|
|
3257
|
-
const parsedBody = parsedOutput.body;
|
|
3258
|
-
return throwDefaultError({
|
|
3259
|
-
output,
|
|
3260
|
-
parsedBody: parsedBody.Error,
|
|
3261
|
-
errorCode
|
|
3262
|
-
});
|
|
3263
|
-
}
|
|
3264
|
-
}, "de_SetInstanceHealthCommandError");
|
|
3265
1966
|
var de_SetInstanceProtectionCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
3266
1967
|
if (output.statusCode >= 300) {
|
|
3267
|
-
return
|
|
1968
|
+
return de_CommandError(output, context);
|
|
3268
1969
|
}
|
|
3269
1970
|
const data = await parseBody(output.body, context);
|
|
3270
1971
|
let contents = {};
|
|
@@ -3275,31 +1976,9 @@ var de_SetInstanceProtectionCommand = /* @__PURE__ */ __name(async (output, cont
|
|
|
3275
1976
|
};
|
|
3276
1977
|
return response;
|
|
3277
1978
|
}, "de_SetInstanceProtectionCommand");
|
|
3278
|
-
var de_SetInstanceProtectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
3279
|
-
const parsedOutput = {
|
|
3280
|
-
...output,
|
|
3281
|
-
body: await parseErrorBody(output.body, context)
|
|
3282
|
-
};
|
|
3283
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
3284
|
-
switch (errorCode) {
|
|
3285
|
-
case "LimitExceeded":
|
|
3286
|
-
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
3287
|
-
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
3288
|
-
case "ResourceContention":
|
|
3289
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
3290
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
3291
|
-
default:
|
|
3292
|
-
const parsedBody = parsedOutput.body;
|
|
3293
|
-
return throwDefaultError({
|
|
3294
|
-
output,
|
|
3295
|
-
parsedBody: parsedBody.Error,
|
|
3296
|
-
errorCode
|
|
3297
|
-
});
|
|
3298
|
-
}
|
|
3299
|
-
}, "de_SetInstanceProtectionCommandError");
|
|
3300
1979
|
var de_StartInstanceRefreshCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
3301
1980
|
if (output.statusCode >= 300) {
|
|
3302
|
-
return
|
|
1981
|
+
return de_CommandError(output, context);
|
|
3303
1982
|
}
|
|
3304
1983
|
const data = await parseBody(output.body, context);
|
|
3305
1984
|
let contents = {};
|
|
@@ -3310,34 +1989,9 @@ var de_StartInstanceRefreshCommand = /* @__PURE__ */ __name(async (output, conte
|
|
|
3310
1989
|
};
|
|
3311
1990
|
return response;
|
|
3312
1991
|
}, "de_StartInstanceRefreshCommand");
|
|
3313
|
-
var de_StartInstanceRefreshCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
3314
|
-
const parsedOutput = {
|
|
3315
|
-
...output,
|
|
3316
|
-
body: await parseErrorBody(output.body, context)
|
|
3317
|
-
};
|
|
3318
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
3319
|
-
switch (errorCode) {
|
|
3320
|
-
case "InstanceRefreshInProgress":
|
|
3321
|
-
case "com.amazonaws.autoscaling#InstanceRefreshInProgressFault":
|
|
3322
|
-
throw await de_InstanceRefreshInProgressFaultRes(parsedOutput, context);
|
|
3323
|
-
case "LimitExceeded":
|
|
3324
|
-
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
3325
|
-
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
3326
|
-
case "ResourceContention":
|
|
3327
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
3328
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
3329
|
-
default:
|
|
3330
|
-
const parsedBody = parsedOutput.body;
|
|
3331
|
-
return throwDefaultError({
|
|
3332
|
-
output,
|
|
3333
|
-
parsedBody: parsedBody.Error,
|
|
3334
|
-
errorCode
|
|
3335
|
-
});
|
|
3336
|
-
}
|
|
3337
|
-
}, "de_StartInstanceRefreshCommandError");
|
|
3338
1992
|
var de_SuspendProcessesCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
3339
1993
|
if (output.statusCode >= 300) {
|
|
3340
|
-
return
|
|
1994
|
+
return de_CommandError(output, context);
|
|
3341
1995
|
}
|
|
3342
1996
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
3343
1997
|
const response = {
|
|
@@ -3345,31 +1999,9 @@ var de_SuspendProcessesCommand = /* @__PURE__ */ __name(async (output, context)
|
|
|
3345
1999
|
};
|
|
3346
2000
|
return response;
|
|
3347
2001
|
}, "de_SuspendProcessesCommand");
|
|
3348
|
-
var de_SuspendProcessesCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
3349
|
-
const parsedOutput = {
|
|
3350
|
-
...output,
|
|
3351
|
-
body: await parseErrorBody(output.body, context)
|
|
3352
|
-
};
|
|
3353
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
3354
|
-
switch (errorCode) {
|
|
3355
|
-
case "ResourceContention":
|
|
3356
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
3357
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
3358
|
-
case "ResourceInUse":
|
|
3359
|
-
case "com.amazonaws.autoscaling#ResourceInUseFault":
|
|
3360
|
-
throw await de_ResourceInUseFaultRes(parsedOutput, context);
|
|
3361
|
-
default:
|
|
3362
|
-
const parsedBody = parsedOutput.body;
|
|
3363
|
-
return throwDefaultError({
|
|
3364
|
-
output,
|
|
3365
|
-
parsedBody: parsedBody.Error,
|
|
3366
|
-
errorCode
|
|
3367
|
-
});
|
|
3368
|
-
}
|
|
3369
|
-
}, "de_SuspendProcessesCommandError");
|
|
3370
2002
|
var de_TerminateInstanceInAutoScalingGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
3371
2003
|
if (output.statusCode >= 300) {
|
|
3372
|
-
return
|
|
2004
|
+
return de_CommandError(output, context);
|
|
3373
2005
|
}
|
|
3374
2006
|
const data = await parseBody(output.body, context);
|
|
3375
2007
|
let contents = {};
|
|
@@ -3380,31 +2012,9 @@ var de_TerminateInstanceInAutoScalingGroupCommand = /* @__PURE__ */ __name(async
|
|
|
3380
2012
|
};
|
|
3381
2013
|
return response;
|
|
3382
2014
|
}, "de_TerminateInstanceInAutoScalingGroupCommand");
|
|
3383
|
-
var de_TerminateInstanceInAutoScalingGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
3384
|
-
const parsedOutput = {
|
|
3385
|
-
...output,
|
|
3386
|
-
body: await parseErrorBody(output.body, context)
|
|
3387
|
-
};
|
|
3388
|
-
const errorCode = loadQueryErrorCode(output, parsedOutput.body);
|
|
3389
|
-
switch (errorCode) {
|
|
3390
|
-
case "ResourceContention":
|
|
3391
|
-
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
3392
|
-
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
3393
|
-
case "ScalingActivityInProgress":
|
|
3394
|
-
case "com.amazonaws.autoscaling#ScalingActivityInProgressFault":
|
|
3395
|
-
throw await de_ScalingActivityInProgressFaultRes(parsedOutput, context);
|
|
3396
|
-
default:
|
|
3397
|
-
const parsedBody = parsedOutput.body;
|
|
3398
|
-
return throwDefaultError({
|
|
3399
|
-
output,
|
|
3400
|
-
parsedBody: parsedBody.Error,
|
|
3401
|
-
errorCode
|
|
3402
|
-
});
|
|
3403
|
-
}
|
|
3404
|
-
}, "de_TerminateInstanceInAutoScalingGroupCommandError");
|
|
3405
2015
|
var de_UpdateAutoScalingGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
|
|
3406
2016
|
if (output.statusCode >= 300) {
|
|
3407
|
-
return
|
|
2017
|
+
return de_CommandError(output, context);
|
|
3408
2018
|
}
|
|
3409
2019
|
await (0, import_smithy_client.collectBody)(output.body, context);
|
|
3410
2020
|
const response = {
|
|
@@ -3412,7 +2022,7 @@ var de_UpdateAutoScalingGroupCommand = /* @__PURE__ */ __name(async (output, con
|
|
|
3412
2022
|
};
|
|
3413
2023
|
return response;
|
|
3414
2024
|
}, "de_UpdateAutoScalingGroupCommand");
|
|
3415
|
-
var
|
|
2025
|
+
var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
|
|
3416
2026
|
const parsedOutput = {
|
|
3417
2027
|
...output,
|
|
3418
2028
|
body: await parseErrorBody(output.body, context)
|
|
@@ -3422,12 +2032,33 @@ var de_UpdateAutoScalingGroupCommandError = /* @__PURE__ */ __name(async (output
|
|
|
3422
2032
|
case "ResourceContention":
|
|
3423
2033
|
case "com.amazonaws.autoscaling#ResourceContentionFault":
|
|
3424
2034
|
throw await de_ResourceContentionFaultRes(parsedOutput, context);
|
|
3425
|
-
case "ScalingActivityInProgress":
|
|
3426
|
-
case "com.amazonaws.autoscaling#ScalingActivityInProgressFault":
|
|
3427
|
-
throw await de_ScalingActivityInProgressFaultRes(parsedOutput, context);
|
|
3428
2035
|
case "ServiceLinkedRoleFailure":
|
|
3429
2036
|
case "com.amazonaws.autoscaling#ServiceLinkedRoleFailure":
|
|
3430
2037
|
throw await de_ServiceLinkedRoleFailureRes(parsedOutput, context);
|
|
2038
|
+
case "AlreadyExists":
|
|
2039
|
+
case "com.amazonaws.autoscaling#AlreadyExistsFault":
|
|
2040
|
+
throw await de_AlreadyExistsFaultRes(parsedOutput, context);
|
|
2041
|
+
case "LimitExceeded":
|
|
2042
|
+
case "com.amazonaws.autoscaling#LimitExceededFault":
|
|
2043
|
+
throw await de_LimitExceededFaultRes(parsedOutput, context);
|
|
2044
|
+
case "ActiveInstanceRefreshNotFound":
|
|
2045
|
+
case "com.amazonaws.autoscaling#ActiveInstanceRefreshNotFoundFault":
|
|
2046
|
+
throw await de_ActiveInstanceRefreshNotFoundFaultRes(parsedOutput, context);
|
|
2047
|
+
case "ResourceInUse":
|
|
2048
|
+
case "com.amazonaws.autoscaling#ResourceInUseFault":
|
|
2049
|
+
throw await de_ResourceInUseFaultRes(parsedOutput, context);
|
|
2050
|
+
case "ScalingActivityInProgress":
|
|
2051
|
+
case "com.amazonaws.autoscaling#ScalingActivityInProgressFault":
|
|
2052
|
+
throw await de_ScalingActivityInProgressFaultRes(parsedOutput, context);
|
|
2053
|
+
case "InvalidNextToken":
|
|
2054
|
+
case "com.amazonaws.autoscaling#InvalidNextToken":
|
|
2055
|
+
throw await de_InvalidNextTokenRes(parsedOutput, context);
|
|
2056
|
+
case "IrreversibleInstanceRefresh":
|
|
2057
|
+
case "com.amazonaws.autoscaling#IrreversibleInstanceRefreshFault":
|
|
2058
|
+
throw await de_IrreversibleInstanceRefreshFaultRes(parsedOutput, context);
|
|
2059
|
+
case "InstanceRefreshInProgress":
|
|
2060
|
+
case "com.amazonaws.autoscaling#InstanceRefreshInProgressFault":
|
|
2061
|
+
throw await de_InstanceRefreshInProgressFaultRes(parsedOutput, context);
|
|
3431
2062
|
default:
|
|
3432
2063
|
const parsedBody = parsedOutput.body;
|
|
3433
2064
|
return throwDefaultError({
|
|
@@ -3436,7 +2067,7 @@ var de_UpdateAutoScalingGroupCommandError = /* @__PURE__ */ __name(async (output
|
|
|
3436
2067
|
errorCode
|
|
3437
2068
|
});
|
|
3438
2069
|
}
|
|
3439
|
-
}, "
|
|
2070
|
+
}, "de_CommandError");
|
|
3440
2071
|
var de_ActiveInstanceRefreshNotFoundFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
|
|
3441
2072
|
const body = parsedOutput.body;
|
|
3442
2073
|
const deserialized = de_ActiveInstanceRefreshNotFoundFault(body.Error, context);
|