@aws-sdk/client-securityhub 3.503.1 → 3.507.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist-cjs/index.js +107 -2489
  2. package/dist-es/protocols/Aws_restJson1.js +183 -2565
  3. package/package.json +3 -3
package/dist-es/protocols/Aws_restJson1.js CHANGED
@@ -1040,7 +1040,7 @@ export const se_UpdateStandardsControlCommand = async (input, context) => {
1040
1040
  };
1041
1041
  export const de_AcceptAdministratorInvitationCommand = async (output, context) => {
1042
1042
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1043
- return de_AcceptAdministratorInvitationCommandError(output, context);
1043
+ return de_CommandError(output, context);
1044
1044
  }
1045
1045
  const contents = map({
1046
1046
  $metadata: deserializeMetadata(output),
@@ -1048,40 +1048,9 @@ export const de_AcceptAdministratorInvitationCommand = async (output, context) =
1048
1048
  await collectBody(output.body, context);
1049
1049
  return contents;
1050
1050
  };
1051
- const de_AcceptAdministratorInvitationCommandError = async (output, context) => {
1052
- const parsedOutput = {
1053
- ...output,
1054
- body: await parseErrorBody(output.body, context),
1055
- };
1056
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1057
- switch (errorCode) {
1058
- case "InternalException":
1059
- case "com.amazonaws.securityhub#InternalException":
1060
- throw await de_InternalExceptionRes(parsedOutput, context);
1061
- case "InvalidAccessException":
1062
- case "com.amazonaws.securityhub#InvalidAccessException":
1063
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1064
- case "InvalidInputException":
1065
- case "com.amazonaws.securityhub#InvalidInputException":
1066
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1067
- case "LimitExceededException":
1068
- case "com.amazonaws.securityhub#LimitExceededException":
1069
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1070
- case "ResourceNotFoundException":
1071
- case "com.amazonaws.securityhub#ResourceNotFoundException":
1072
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1073
- default:
1074
- const parsedBody = parsedOutput.body;
1075
- return throwDefaultError({
1076
- output,
1077
- parsedBody,
1078
- errorCode,
1079
- });
1080
- }
1081
- };
1082
1051
  export const de_AcceptInvitationCommand = async (output, context) => {
1083
1052
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1084
- return de_AcceptInvitationCommandError(output, context);
1053
+ return de_CommandError(output, context);
1085
1054
  }
1086
1055
  const contents = map({
1087
1056
  $metadata: deserializeMetadata(output),
@@ -1089,40 +1058,9 @@ export const de_AcceptInvitationCommand = async (output, context) => {
1089
1058
  await collectBody(output.body, context);
1090
1059
  return contents;
1091
1060
  };
1092
- const de_AcceptInvitationCommandError = async (output, context) => {
1093
- const parsedOutput = {
1094
- ...output,
1095
- body: await parseErrorBody(output.body, context),
1096
- };
1097
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1098
- switch (errorCode) {
1099
- case "InternalException":
1100
- case "com.amazonaws.securityhub#InternalException":
1101
- throw await de_InternalExceptionRes(parsedOutput, context);
1102
- case "InvalidAccessException":
1103
- case "com.amazonaws.securityhub#InvalidAccessException":
1104
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1105
- case "InvalidInputException":
1106
- case "com.amazonaws.securityhub#InvalidInputException":
1107
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1108
- case "LimitExceededException":
1109
- case "com.amazonaws.securityhub#LimitExceededException":
1110
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1111
- case "ResourceNotFoundException":
1112
- case "com.amazonaws.securityhub#ResourceNotFoundException":
1113
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1114
- default:
1115
- const parsedBody = parsedOutput.body;
1116
- return throwDefaultError({
1117
- output,
1118
- parsedBody,
1119
- errorCode,
1120
- });
1121
- }
1122
- };
1123
1061
  export const de_BatchDeleteAutomationRulesCommand = async (output, context) => {
1124
1062
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1125
- return de_BatchDeleteAutomationRulesCommandError(output, context);
1063
+ return de_CommandError(output, context);
1126
1064
  }
1127
1065
  const contents = map({
1128
1066
  $metadata: deserializeMetadata(output),
@@ -1135,40 +1073,9 @@ export const de_BatchDeleteAutomationRulesCommand = async (output, context) => {
1135
1073
  Object.assign(contents, doc);
1136
1074
  return contents;
1137
1075
  };
1138
- const de_BatchDeleteAutomationRulesCommandError = async (output, context) => {
1139
- const parsedOutput = {
1140
- ...output,
1141
- body: await parseErrorBody(output.body, context),
1142
- };
1143
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1144
- switch (errorCode) {
1145
- case "InternalException":
1146
- case "com.amazonaws.securityhub#InternalException":
1147
- throw await de_InternalExceptionRes(parsedOutput, context);
1148
- case "InvalidAccessException":
1149
- case "com.amazonaws.securityhub#InvalidAccessException":
1150
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1151
- case "InvalidInputException":
1152
- case "com.amazonaws.securityhub#InvalidInputException":
1153
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1154
- case "LimitExceededException":
1155
- case "com.amazonaws.securityhub#LimitExceededException":
1156
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1157
- case "ResourceNotFoundException":
1158
- case "com.amazonaws.securityhub#ResourceNotFoundException":
1159
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1160
- default:
1161
- const parsedBody = parsedOutput.body;
1162
- return throwDefaultError({
1163
- output,
1164
- parsedBody,
1165
- errorCode,
1166
- });
1167
- }
1168
- };
1169
1076
  export const de_BatchDisableStandardsCommand = async (output, context) => {
1170
1077
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1171
- return de_BatchDisableStandardsCommandError(output, context);
1078
+ return de_CommandError(output, context);
1172
1079
  }
1173
1080
  const contents = map({
1174
1081
  $metadata: deserializeMetadata(output),
@@ -1180,40 +1087,9 @@ export const de_BatchDisableStandardsCommand = async (output, context) => {
1180
1087
  Object.assign(contents, doc);
1181
1088
  return contents;
1182
1089
  };
1183
- const de_BatchDisableStandardsCommandError = async (output, context) => {
1184
- const parsedOutput = {
1185
- ...output,
1186
- body: await parseErrorBody(output.body, context),
1187
- };
1188
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1189
- switch (errorCode) {
1190
- case "AccessDeniedException":
1191
- case "com.amazonaws.securityhub#AccessDeniedException":
1192
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1193
- case "InternalException":
1194
- case "com.amazonaws.securityhub#InternalException":
1195
- throw await de_InternalExceptionRes(parsedOutput, context);
1196
- case "InvalidAccessException":
1197
- case "com.amazonaws.securityhub#InvalidAccessException":
1198
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1199
- case "InvalidInputException":
1200
- case "com.amazonaws.securityhub#InvalidInputException":
1201
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1202
- case "LimitExceededException":
1203
- case "com.amazonaws.securityhub#LimitExceededException":
1204
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1205
- default:
1206
- const parsedBody = parsedOutput.body;
1207
- return throwDefaultError({
1208
- output,
1209
- parsedBody,
1210
- errorCode,
1211
- });
1212
- }
1213
- };
1214
1090
  export const de_BatchEnableStandardsCommand = async (output, context) => {
1215
1091
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1216
- return de_BatchEnableStandardsCommandError(output, context);
1092
+ return de_CommandError(output, context);
1217
1093
  }
1218
1094
  const contents = map({
1219
1095
  $metadata: deserializeMetadata(output),
@@ -1225,40 +1101,9 @@ export const de_BatchEnableStandardsCommand = async (output, context) => {
1225
1101
  Object.assign(contents, doc);
1226
1102
  return contents;
1227
1103
  };
1228
- const de_BatchEnableStandardsCommandError = async (output, context) => {
1229
- const parsedOutput = {
1230
- ...output,
1231
- body: await parseErrorBody(output.body, context),
1232
- };
1233
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1234
- switch (errorCode) {
1235
- case "AccessDeniedException":
1236
- case "com.amazonaws.securityhub#AccessDeniedException":
1237
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1238
- case "InternalException":
1239
- case "com.amazonaws.securityhub#InternalException":
1240
- throw await de_InternalExceptionRes(parsedOutput, context);
1241
- case "InvalidAccessException":
1242
- case "com.amazonaws.securityhub#InvalidAccessException":
1243
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1244
- case "InvalidInputException":
1245
- case "com.amazonaws.securityhub#InvalidInputException":
1246
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1247
- case "LimitExceededException":
1248
- case "com.amazonaws.securityhub#LimitExceededException":
1249
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1250
- default:
1251
- const parsedBody = parsedOutput.body;
1252
- return throwDefaultError({
1253
- output,
1254
- parsedBody,
1255
- errorCode,
1256
- });
1257
- }
1258
- };
1259
1104
  export const de_BatchGetAutomationRulesCommand = async (output, context) => {
1260
1105
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1261
- return de_BatchGetAutomationRulesCommandError(output, context);
1106
+ return de_CommandError(output, context);
1262
1107
  }
1263
1108
  const contents = map({
1264
1109
  $metadata: deserializeMetadata(output),
@@ -1271,43 +1116,9 @@ export const de_BatchGetAutomationRulesCommand = async (output, context) => {
1271
1116
  Object.assign(contents, doc);
1272
1117
  return contents;
1273
1118
  };
1274
- const de_BatchGetAutomationRulesCommandError = async (output, context) => {
1275
- const parsedOutput = {
1276
- ...output,
1277
- body: await parseErrorBody(output.body, context),
1278
- };
1279
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1280
- switch (errorCode) {
1281
- case "AccessDeniedException":
1282
- case "com.amazonaws.securityhub#AccessDeniedException":
1283
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1284
- case "InternalException":
1285
- case "com.amazonaws.securityhub#InternalException":
1286
- throw await de_InternalExceptionRes(parsedOutput, context);
1287
- case "InvalidAccessException":
1288
- case "com.amazonaws.securityhub#InvalidAccessException":
1289
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1290
- case "InvalidInputException":
1291
- case "com.amazonaws.securityhub#InvalidInputException":
1292
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1293
- case "LimitExceededException":
1294
- case "com.amazonaws.securityhub#LimitExceededException":
1295
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1296
- case "ResourceNotFoundException":
1297
- case "com.amazonaws.securityhub#ResourceNotFoundException":
1298
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1299
- default:
1300
- const parsedBody = parsedOutput.body;
1301
- return throwDefaultError({
1302
- output,
1303
- parsedBody,
1304
- errorCode,
1305
- });
1306
- }
1307
- };
1308
1119
  export const de_BatchGetConfigurationPolicyAssociationsCommand = async (output, context) => {
1309
1120
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1310
- return de_BatchGetConfigurationPolicyAssociationsCommandError(output, context);
1121
+ return de_CommandError(output, context);
1311
1122
  }
1312
1123
  const contents = map({
1313
1124
  $metadata: deserializeMetadata(output),
@@ -1320,43 +1131,9 @@ export const de_BatchGetConfigurationPolicyAssociationsCommand = async (output,
1320
1131
  Object.assign(contents, doc);
1321
1132
  return contents;
1322
1133
  };
1323
- const de_BatchGetConfigurationPolicyAssociationsCommandError = async (output, context) => {
1324
- const parsedOutput = {
1325
- ...output,
1326
- body: await parseErrorBody(output.body, context),
1327
- };
1328
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1329
- switch (errorCode) {
1330
- case "AccessDeniedException":
1331
- case "com.amazonaws.securityhub#AccessDeniedException":
1332
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1333
- case "InternalException":
1334
- case "com.amazonaws.securityhub#InternalException":
1335
- throw await de_InternalExceptionRes(parsedOutput, context);
1336
- case "InvalidAccessException":
1337
- case "com.amazonaws.securityhub#InvalidAccessException":
1338
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1339
- case "InvalidInputException":
1340
- case "com.amazonaws.securityhub#InvalidInputException":
1341
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1342
- case "LimitExceededException":
1343
- case "com.amazonaws.securityhub#LimitExceededException":
1344
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1345
- case "ResourceNotFoundException":
1346
- case "com.amazonaws.securityhub#ResourceNotFoundException":
1347
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1348
- default:
1349
- const parsedBody = parsedOutput.body;
1350
- return throwDefaultError({
1351
- output,
1352
- parsedBody,
1353
- errorCode,
1354
- });
1355
- }
1356
- };
1357
1134
  export const de_BatchGetSecurityControlsCommand = async (output, context) => {
1358
1135
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1359
- return de_BatchGetSecurityControlsCommandError(output, context);
1136
+ return de_CommandError(output, context);
1360
1137
  }
1361
1138
  const contents = map({
1362
1139
  $metadata: deserializeMetadata(output),
@@ -1369,37 +1146,9 @@ export const de_BatchGetSecurityControlsCommand = async (output, context) => {
1369
1146
  Object.assign(contents, doc);
1370
1147
  return contents;
1371
1148
  };
1372
- const de_BatchGetSecurityControlsCommandError = async (output, context) => {
1373
- const parsedOutput = {
1374
- ...output,
1375
- body: await parseErrorBody(output.body, context),
1376
- };
1377
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1378
- switch (errorCode) {
1379
- case "InternalException":
1380
- case "com.amazonaws.securityhub#InternalException":
1381
- throw await de_InternalExceptionRes(parsedOutput, context);
1382
- case "InvalidAccessException":
1383
- case "com.amazonaws.securityhub#InvalidAccessException":
1384
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1385
- case "InvalidInputException":
1386
- case "com.amazonaws.securityhub#InvalidInputException":
1387
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1388
- case "LimitExceededException":
1389
- case "com.amazonaws.securityhub#LimitExceededException":
1390
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1391
- default:
1392
- const parsedBody = parsedOutput.body;
1393
- return throwDefaultError({
1394
- output,
1395
- parsedBody,
1396
- errorCode,
1397
- });
1398
- }
1399
- };
1400
1149
  export const de_BatchGetStandardsControlAssociationsCommand = async (output, context) => {
1401
1150
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1402
- return de_BatchGetStandardsControlAssociationsCommandError(output, context);
1151
+ return de_CommandError(output, context);
1403
1152
  }
1404
1153
  const contents = map({
1405
1154
  $metadata: deserializeMetadata(output),
@@ -1412,37 +1161,9 @@ export const de_BatchGetStandardsControlAssociationsCommand = async (output, con
1412
1161
  Object.assign(contents, doc);
1413
1162
  return contents;
1414
1163
  };
1415
- const de_BatchGetStandardsControlAssociationsCommandError = async (output, context) => {
1416
- const parsedOutput = {
1417
- ...output,
1418
- body: await parseErrorBody(output.body, context),
1419
- };
1420
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1421
- switch (errorCode) {
1422
- case "InternalException":
1423
- case "com.amazonaws.securityhub#InternalException":
1424
- throw await de_InternalExceptionRes(parsedOutput, context);
1425
- case "InvalidAccessException":
1426
- case "com.amazonaws.securityhub#InvalidAccessException":
1427
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1428
- case "InvalidInputException":
1429
- case "com.amazonaws.securityhub#InvalidInputException":
1430
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1431
- case "LimitExceededException":
1432
- case "com.amazonaws.securityhub#LimitExceededException":
1433
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1434
- default:
1435
- const parsedBody = parsedOutput.body;
1436
- return throwDefaultError({
1437
- output,
1438
- parsedBody,
1439
- errorCode,
1440
- });
1441
- }
1442
- };
1443
1164
  export const de_BatchImportFindingsCommand = async (output, context) => {
1444
1165
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1445
- return de_BatchImportFindingsCommandError(output, context);
1166
+ return de_CommandError(output, context);
1446
1167
  }
1447
1168
  const contents = map({
1448
1169
  $metadata: deserializeMetadata(output),
@@ -1456,37 +1177,9 @@ export const de_BatchImportFindingsCommand = async (output, context) => {
1456
1177
  Object.assign(contents, doc);
1457
1178
  return contents;
1458
1179
  };
1459
- const de_BatchImportFindingsCommandError = async (output, context) => {
1460
- const parsedOutput = {
1461
- ...output,
1462
- body: await parseErrorBody(output.body, context),
1463
- };
1464
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1465
- switch (errorCode) {
1466
- case "InternalException":
1467
- case "com.amazonaws.securityhub#InternalException":
1468
- throw await de_InternalExceptionRes(parsedOutput, context);
1469
- case "InvalidAccessException":
1470
- case "com.amazonaws.securityhub#InvalidAccessException":
1471
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1472
- case "InvalidInputException":
1473
- case "com.amazonaws.securityhub#InvalidInputException":
1474
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1475
- case "LimitExceededException":
1476
- case "com.amazonaws.securityhub#LimitExceededException":
1477
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1478
- default:
1479
- const parsedBody = parsedOutput.body;
1480
- return throwDefaultError({
1481
- output,
1482
- parsedBody,
1483
- errorCode,
1484
- });
1485
- }
1486
- };
1487
1180
  export const de_BatchUpdateAutomationRulesCommand = async (output, context) => {
1488
1181
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1489
- return de_BatchUpdateAutomationRulesCommandError(output, context);
1182
+ return de_CommandError(output, context);
1490
1183
  }
1491
1184
  const contents = map({
1492
1185
  $metadata: deserializeMetadata(output),
@@ -1499,40 +1192,9 @@ export const de_BatchUpdateAutomationRulesCommand = async (output, context) => {
1499
1192
  Object.assign(contents, doc);
1500
1193
  return contents;
1501
1194
  };
1502
- const de_BatchUpdateAutomationRulesCommandError = async (output, context) => {
1503
- const parsedOutput = {
1504
- ...output,
1505
- body: await parseErrorBody(output.body, context),
1506
- };
1507
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1508
- switch (errorCode) {
1509
- case "InternalException":
1510
- case "com.amazonaws.securityhub#InternalException":
1511
- throw await de_InternalExceptionRes(parsedOutput, context);
1512
- case "InvalidAccessException":
1513
- case "com.amazonaws.securityhub#InvalidAccessException":
1514
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1515
- case "InvalidInputException":
1516
- case "com.amazonaws.securityhub#InvalidInputException":
1517
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1518
- case "LimitExceededException":
1519
- case "com.amazonaws.securityhub#LimitExceededException":
1520
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1521
- case "ResourceNotFoundException":
1522
- case "com.amazonaws.securityhub#ResourceNotFoundException":
1523
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1524
- default:
1525
- const parsedBody = parsedOutput.body;
1526
- return throwDefaultError({
1527
- output,
1528
- parsedBody,
1529
- errorCode,
1530
- });
1531
- }
1532
- };
1533
1195
  export const de_BatchUpdateFindingsCommand = async (output, context) => {
1534
1196
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1535
- return de_BatchUpdateFindingsCommandError(output, context);
1197
+ return de_CommandError(output, context);
1536
1198
  }
1537
1199
  const contents = map({
1538
1200
  $metadata: deserializeMetadata(output),
@@ -1545,37 +1207,9 @@ export const de_BatchUpdateFindingsCommand = async (output, context) => {
1545
1207
  Object.assign(contents, doc);
1546
1208
  return contents;
1547
1209
  };
1548
- const de_BatchUpdateFindingsCommandError = async (output, context) => {
1549
- const parsedOutput = {
1550
- ...output,
1551
- body: await parseErrorBody(output.body, context),
1552
- };
1553
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1554
- switch (errorCode) {
1555
- case "InternalException":
1556
- case "com.amazonaws.securityhub#InternalException":
1557
- throw await de_InternalExceptionRes(parsedOutput, context);
1558
- case "InvalidAccessException":
1559
- case "com.amazonaws.securityhub#InvalidAccessException":
1560
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1561
- case "InvalidInputException":
1562
- case "com.amazonaws.securityhub#InvalidInputException":
1563
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1564
- case "LimitExceededException":
1565
- case "com.amazonaws.securityhub#LimitExceededException":
1566
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1567
- default:
1568
- const parsedBody = parsedOutput.body;
1569
- return throwDefaultError({
1570
- output,
1571
- parsedBody,
1572
- errorCode,
1573
- });
1574
- }
1575
- };
1576
1210
  export const de_BatchUpdateStandardsControlAssociationsCommand = async (output, context) => {
1577
1211
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1578
- return de_BatchUpdateStandardsControlAssociationsCommandError(output, context);
1212
+ return de_CommandError(output, context);
1579
1213
  }
1580
1214
  const contents = map({
1581
1215
  $metadata: deserializeMetadata(output),
@@ -1587,40 +1221,9 @@ export const de_BatchUpdateStandardsControlAssociationsCommand = async (output,
1587
1221
  Object.assign(contents, doc);
1588
1222
  return contents;
1589
1223
  };
1590
- const de_BatchUpdateStandardsControlAssociationsCommandError = async (output, context) => {
1591
- const parsedOutput = {
1592
- ...output,
1593
- body: await parseErrorBody(output.body, context),
1594
- };
1595
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1596
- switch (errorCode) {
1597
- case "AccessDeniedException":
1598
- case "com.amazonaws.securityhub#AccessDeniedException":
1599
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1600
- case "InternalException":
1601
- case "com.amazonaws.securityhub#InternalException":
1602
- throw await de_InternalExceptionRes(parsedOutput, context);
1603
- case "InvalidAccessException":
1604
- case "com.amazonaws.securityhub#InvalidAccessException":
1605
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1606
- case "InvalidInputException":
1607
- case "com.amazonaws.securityhub#InvalidInputException":
1608
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1609
- case "LimitExceededException":
1610
- case "com.amazonaws.securityhub#LimitExceededException":
1611
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1612
- default:
1613
- const parsedBody = parsedOutput.body;
1614
- return throwDefaultError({
1615
- output,
1616
- parsedBody,
1617
- errorCode,
1618
- });
1619
- }
1620
- };
1621
1224
  export const de_CreateActionTargetCommand = async (output, context) => {
1622
1225
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1623
- return de_CreateActionTargetCommandError(output, context);
1226
+ return de_CommandError(output, context);
1624
1227
  }
1625
1228
  const contents = map({
1626
1229
  $metadata: deserializeMetadata(output),
@@ -1632,40 +1235,9 @@ export const de_CreateActionTargetCommand = async (output, context) => {
1632
1235
  Object.assign(contents, doc);
1633
1236
  return contents;
1634
1237
  };
1635
- const de_CreateActionTargetCommandError = async (output, context) => {
1636
- const parsedOutput = {
1637
- ...output,
1638
- body: await parseErrorBody(output.body, context),
1639
- };
1640
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1641
- switch (errorCode) {
1642
- case "InternalException":
1643
- case "com.amazonaws.securityhub#InternalException":
1644
- throw await de_InternalExceptionRes(parsedOutput, context);
1645
- case "InvalidAccessException":
1646
- case "com.amazonaws.securityhub#InvalidAccessException":
1647
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1648
- case "InvalidInputException":
1649
- case "com.amazonaws.securityhub#InvalidInputException":
1650
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1651
- case "LimitExceededException":
1652
- case "com.amazonaws.securityhub#LimitExceededException":
1653
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1654
- case "ResourceConflictException":
1655
- case "com.amazonaws.securityhub#ResourceConflictException":
1656
- throw await de_ResourceConflictExceptionRes(parsedOutput, context);
1657
- default:
1658
- const parsedBody = parsedOutput.body;
1659
- return throwDefaultError({
1660
- output,
1661
- parsedBody,
1662
- errorCode,
1663
- });
1664
- }
1665
- };
1666
1238
  export const de_CreateAutomationRuleCommand = async (output, context) => {
1667
1239
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1668
- return de_CreateAutomationRuleCommandError(output, context);
1240
+ return de_CommandError(output, context);
1669
1241
  }
1670
1242
  const contents = map({
1671
1243
  $metadata: deserializeMetadata(output),
@@ -1677,40 +1249,9 @@ export const de_CreateAutomationRuleCommand = async (output, context) => {
1677
1249
  Object.assign(contents, doc);
1678
1250
  return contents;
1679
1251
  };
1680
- const de_CreateAutomationRuleCommandError = async (output, context) => {
1681
- const parsedOutput = {
1682
- ...output,
1683
- body: await parseErrorBody(output.body, context),
1684
- };
1685
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1686
- switch (errorCode) {
1687
- case "AccessDeniedException":
1688
- case "com.amazonaws.securityhub#AccessDeniedException":
1689
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1690
- case "InternalException":
1691
- case "com.amazonaws.securityhub#InternalException":
1692
- throw await de_InternalExceptionRes(parsedOutput, context);
1693
- case "InvalidAccessException":
1694
- case "com.amazonaws.securityhub#InvalidAccessException":
1695
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1696
- case "InvalidInputException":
1697
- case "com.amazonaws.securityhub#InvalidInputException":
1698
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1699
- case "LimitExceededException":
1700
- case "com.amazonaws.securityhub#LimitExceededException":
1701
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1702
- default:
1703
- const parsedBody = parsedOutput.body;
1704
- return throwDefaultError({
1705
- output,
1706
- parsedBody,
1707
- errorCode,
1708
- });
1709
- }
1710
- };
1711
1252
  export const de_CreateConfigurationPolicyCommand = async (output, context) => {
1712
1253
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1713
- return de_CreateConfigurationPolicyCommandError(output, context);
1254
+ return de_CommandError(output, context);
1714
1255
  }
1715
1256
  const contents = map({
1716
1257
  $metadata: deserializeMetadata(output),
@@ -1728,43 +1269,9 @@ export const de_CreateConfigurationPolicyCommand = async (output, context) => {
1728
1269
  Object.assign(contents, doc);
1729
1270
  return contents;
1730
1271
  };
1731
- const de_CreateConfigurationPolicyCommandError = async (output, context) => {
1732
- const parsedOutput = {
1733
- ...output,
1734
- body: await parseErrorBody(output.body, context),
1735
- };
1736
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1737
- switch (errorCode) {
1738
- case "AccessDeniedException":
1739
- case "com.amazonaws.securityhub#AccessDeniedException":
1740
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1741
- case "InternalException":
1742
- case "com.amazonaws.securityhub#InternalException":
1743
- throw await de_InternalExceptionRes(parsedOutput, context);
1744
- case "InvalidAccessException":
1745
- case "com.amazonaws.securityhub#InvalidAccessException":
1746
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1747
- case "InvalidInputException":
1748
- case "com.amazonaws.securityhub#InvalidInputException":
1749
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1750
- case "LimitExceededException":
1751
- case "com.amazonaws.securityhub#LimitExceededException":
1752
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1753
- case "ResourceConflictException":
1754
- case "com.amazonaws.securityhub#ResourceConflictException":
1755
- throw await de_ResourceConflictExceptionRes(parsedOutput, context);
1756
- default:
1757
- const parsedBody = parsedOutput.body;
1758
- return throwDefaultError({
1759
- output,
1760
- parsedBody,
1761
- errorCode,
1762
- });
1763
- }
1764
- };
1765
1272
  export const de_CreateFindingAggregatorCommand = async (output, context) => {
1766
1273
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1767
- return de_CreateFindingAggregatorCommandError(output, context);
1274
+ return de_CommandError(output, context);
1768
1275
  }
1769
1276
  const contents = map({
1770
1277
  $metadata: deserializeMetadata(output),
@@ -1779,40 +1286,9 @@ export const de_CreateFindingAggregatorCommand = async (output, context) => {
1779
1286
  Object.assign(contents, doc);
1780
1287
  return contents;
1781
1288
  };
1782
- const de_CreateFindingAggregatorCommandError = async (output, context) => {
1783
- const parsedOutput = {
1784
- ...output,
1785
- body: await parseErrorBody(output.body, context),
1786
- };
1787
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1788
- switch (errorCode) {
1789
- case "AccessDeniedException":
1790
- case "com.amazonaws.securityhub#AccessDeniedException":
1791
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1792
- case "InternalException":
1793
- case "com.amazonaws.securityhub#InternalException":
1794
- throw await de_InternalExceptionRes(parsedOutput, context);
1795
- case "InvalidAccessException":
1796
- case "com.amazonaws.securityhub#InvalidAccessException":
1797
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1798
- case "InvalidInputException":
1799
- case "com.amazonaws.securityhub#InvalidInputException":
1800
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1801
- case "LimitExceededException":
1802
- case "com.amazonaws.securityhub#LimitExceededException":
1803
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1804
- default:
1805
- const parsedBody = parsedOutput.body;
1806
- return throwDefaultError({
1807
- output,
1808
- parsedBody,
1809
- errorCode,
1810
- });
1811
- }
1812
- };
1813
1289
  export const de_CreateInsightCommand = async (output, context) => {
1814
1290
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1815
- return de_CreateInsightCommandError(output, context);
1291
+ return de_CommandError(output, context);
1816
1292
  }
1817
1293
  const contents = map({
1818
1294
  $metadata: deserializeMetadata(output),
@@ -1824,40 +1300,9 @@ export const de_CreateInsightCommand = async (output, context) => {
1824
1300
  Object.assign(contents, doc);
1825
1301
  return contents;
1826
1302
  };
1827
- const de_CreateInsightCommandError = async (output, context) => {
1828
- const parsedOutput = {
1829
- ...output,
1830
- body: await parseErrorBody(output.body, context),
1831
- };
1832
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1833
- switch (errorCode) {
1834
- case "InternalException":
1835
- case "com.amazonaws.securityhub#InternalException":
1836
- throw await de_InternalExceptionRes(parsedOutput, context);
1837
- case "InvalidAccessException":
1838
- case "com.amazonaws.securityhub#InvalidAccessException":
1839
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1840
- case "InvalidInputException":
1841
- case "com.amazonaws.securityhub#InvalidInputException":
1842
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1843
- case "LimitExceededException":
1844
- case "com.amazonaws.securityhub#LimitExceededException":
1845
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1846
- case "ResourceConflictException":
1847
- case "com.amazonaws.securityhub#ResourceConflictException":
1848
- throw await de_ResourceConflictExceptionRes(parsedOutput, context);
1849
- default:
1850
- const parsedBody = parsedOutput.body;
1851
- return throwDefaultError({
1852
- output,
1853
- parsedBody,
1854
- errorCode,
1855
- });
1856
- }
1857
- };
1858
1303
  export const de_CreateMembersCommand = async (output, context) => {
1859
1304
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1860
- return de_CreateMembersCommandError(output, context);
1305
+ return de_CommandError(output, context);
1861
1306
  }
1862
1307
  const contents = map({
1863
1308
  $metadata: deserializeMetadata(output),
@@ -1869,43 +1314,9 @@ export const de_CreateMembersCommand = async (output, context) => {
1869
1314
  Object.assign(contents, doc);
1870
1315
  return contents;
1871
1316
  };
1872
- const de_CreateMembersCommandError = async (output, context) => {
1873
- const parsedOutput = {
1874
- ...output,
1875
- body: await parseErrorBody(output.body, context),
1876
- };
1877
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1878
- switch (errorCode) {
1879
- case "AccessDeniedException":
1880
- case "com.amazonaws.securityhub#AccessDeniedException":
1881
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
1882
- case "InternalException":
1883
- case "com.amazonaws.securityhub#InternalException":
1884
- throw await de_InternalExceptionRes(parsedOutput, context);
1885
- case "InvalidAccessException":
1886
- case "com.amazonaws.securityhub#InvalidAccessException":
1887
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1888
- case "InvalidInputException":
1889
- case "com.amazonaws.securityhub#InvalidInputException":
1890
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1891
- case "LimitExceededException":
1892
- case "com.amazonaws.securityhub#LimitExceededException":
1893
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1894
- case "ResourceConflictException":
1895
- case "com.amazonaws.securityhub#ResourceConflictException":
1896
- throw await de_ResourceConflictExceptionRes(parsedOutput, context);
1897
- default:
1898
- const parsedBody = parsedOutput.body;
1899
- return throwDefaultError({
1900
- output,
1901
- parsedBody,
1902
- errorCode,
1903
- });
1904
- }
1905
- };
1906
1317
  export const de_DeclineInvitationsCommand = async (output, context) => {
1907
1318
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1908
- return de_DeclineInvitationsCommandError(output, context);
1319
+ return de_CommandError(output, context);
1909
1320
  }
1910
1321
  const contents = map({
1911
1322
  $metadata: deserializeMetadata(output),
@@ -1917,37 +1328,9 @@ export const de_DeclineInvitationsCommand = async (output, context) => {
1917
1328
  Object.assign(contents, doc);
1918
1329
  return contents;
1919
1330
  };
1920
- const de_DeclineInvitationsCommandError = async (output, context) => {
1921
- const parsedOutput = {
1922
- ...output,
1923
- body: await parseErrorBody(output.body, context),
1924
- };
1925
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1926
- switch (errorCode) {
1927
- case "InternalException":
1928
- case "com.amazonaws.securityhub#InternalException":
1929
- throw await de_InternalExceptionRes(parsedOutput, context);
1930
- case "InvalidAccessException":
1931
- case "com.amazonaws.securityhub#InvalidAccessException":
1932
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1933
- case "InvalidInputException":
1934
- case "com.amazonaws.securityhub#InvalidInputException":
1935
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1936
- case "ResourceNotFoundException":
1937
- case "com.amazonaws.securityhub#ResourceNotFoundException":
1938
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1939
- default:
1940
- const parsedBody = parsedOutput.body;
1941
- return throwDefaultError({
1942
- output,
1943
- parsedBody,
1944
- errorCode,
1945
- });
1946
- }
1947
- };
1948
1331
  export const de_DeleteActionTargetCommand = async (output, context) => {
1949
1332
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1950
- return de_DeleteActionTargetCommandError(output, context);
1333
+ return de_CommandError(output, context);
1951
1334
  }
1952
1335
  const contents = map({
1953
1336
  $metadata: deserializeMetadata(output),
@@ -1959,37 +1342,9 @@ export const de_DeleteActionTargetCommand = async (output, context) => {
1959
1342
  Object.assign(contents, doc);
1960
1343
  return contents;
1961
1344
  };
1962
- const de_DeleteActionTargetCommandError = async (output, context) => {
1963
- const parsedOutput = {
1964
- ...output,
1965
- body: await parseErrorBody(output.body, context),
1966
- };
1967
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1968
- switch (errorCode) {
1969
- case "InternalException":
1970
- case "com.amazonaws.securityhub#InternalException":
1971
- throw await de_InternalExceptionRes(parsedOutput, context);
1972
- case "InvalidAccessException":
1973
- case "com.amazonaws.securityhub#InvalidAccessException":
1974
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
1975
- case "InvalidInputException":
1976
- case "com.amazonaws.securityhub#InvalidInputException":
1977
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
1978
- case "ResourceNotFoundException":
1979
- case "com.amazonaws.securityhub#ResourceNotFoundException":
1980
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
1981
- default:
1982
- const parsedBody = parsedOutput.body;
1983
- return throwDefaultError({
1984
- output,
1985
- parsedBody,
1986
- errorCode,
1987
- });
1988
- }
1989
- };
1990
1345
  export const de_DeleteConfigurationPolicyCommand = async (output, context) => {
1991
1346
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1992
- return de_DeleteConfigurationPolicyCommandError(output, context);
1347
+ return de_CommandError(output, context);
1993
1348
  }
1994
1349
  const contents = map({
1995
1350
  $metadata: deserializeMetadata(output),
@@ -1997,46 +1352,9 @@ export const de_DeleteConfigurationPolicyCommand = async (output, context) => {
1997
1352
  await collectBody(output.body, context);
1998
1353
  return contents;
1999
1354
  };
2000
- const de_DeleteConfigurationPolicyCommandError = async (output, context) => {
2001
- const parsedOutput = {
2002
- ...output,
2003
- body: await parseErrorBody(output.body, context),
2004
- };
2005
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2006
- switch (errorCode) {
2007
- case "AccessDeniedException":
2008
- case "com.amazonaws.securityhub#AccessDeniedException":
2009
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2010
- case "InternalException":
2011
- case "com.amazonaws.securityhub#InternalException":
2012
- throw await de_InternalExceptionRes(parsedOutput, context);
2013
- case "InvalidAccessException":
2014
- case "com.amazonaws.securityhub#InvalidAccessException":
2015
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2016
- case "InvalidInputException":
2017
- case "com.amazonaws.securityhub#InvalidInputException":
2018
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2019
- case "LimitExceededException":
2020
- case "com.amazonaws.securityhub#LimitExceededException":
2021
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2022
- case "ResourceConflictException":
2023
- case "com.amazonaws.securityhub#ResourceConflictException":
2024
- throw await de_ResourceConflictExceptionRes(parsedOutput, context);
2025
- case "ResourceNotFoundException":
2026
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2027
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2028
- default:
2029
- const parsedBody = parsedOutput.body;
2030
- return throwDefaultError({
2031
- output,
2032
- parsedBody,
2033
- errorCode,
2034
- });
2035
- }
2036
- };
2037
1355
  export const de_DeleteFindingAggregatorCommand = async (output, context) => {
2038
1356
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2039
- return de_DeleteFindingAggregatorCommandError(output, context);
1357
+ return de_CommandError(output, context);
2040
1358
  }
2041
1359
  const contents = map({
2042
1360
  $metadata: deserializeMetadata(output),
@@ -2044,43 +1362,9 @@ export const de_DeleteFindingAggregatorCommand = async (output, context) => {
2044
1362
  await collectBody(output.body, context);
2045
1363
  return contents;
2046
1364
  };
2047
- const de_DeleteFindingAggregatorCommandError = async (output, context) => {
2048
- const parsedOutput = {
2049
- ...output,
2050
- body: await parseErrorBody(output.body, context),
2051
- };
2052
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2053
- switch (errorCode) {
2054
- case "AccessDeniedException":
2055
- case "com.amazonaws.securityhub#AccessDeniedException":
2056
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2057
- case "InternalException":
2058
- case "com.amazonaws.securityhub#InternalException":
2059
- throw await de_InternalExceptionRes(parsedOutput, context);
2060
- case "InvalidAccessException":
2061
- case "com.amazonaws.securityhub#InvalidAccessException":
2062
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2063
- case "InvalidInputException":
2064
- case "com.amazonaws.securityhub#InvalidInputException":
2065
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2066
- case "LimitExceededException":
2067
- case "com.amazonaws.securityhub#LimitExceededException":
2068
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2069
- case "ResourceNotFoundException":
2070
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2071
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2072
- default:
2073
- const parsedBody = parsedOutput.body;
2074
- return throwDefaultError({
2075
- output,
2076
- parsedBody,
2077
- errorCode,
2078
- });
2079
- }
2080
- };
2081
1365
  export const de_DeleteInsightCommand = async (output, context) => {
2082
1366
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2083
- return de_DeleteInsightCommandError(output, context);
1367
+ return de_CommandError(output, context);
2084
1368
  }
2085
1369
  const contents = map({
2086
1370
  $metadata: deserializeMetadata(output),
@@ -2092,40 +1376,9 @@ export const de_DeleteInsightCommand = async (output, context) => {
2092
1376
  Object.assign(contents, doc);
2093
1377
  return contents;
2094
1378
  };
2095
- const de_DeleteInsightCommandError = async (output, context) => {
2096
- const parsedOutput = {
2097
- ...output,
2098
- body: await parseErrorBody(output.body, context),
2099
- };
2100
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2101
- switch (errorCode) {
2102
- case "InternalException":
2103
- case "com.amazonaws.securityhub#InternalException":
2104
- throw await de_InternalExceptionRes(parsedOutput, context);
2105
- case "InvalidAccessException":
2106
- case "com.amazonaws.securityhub#InvalidAccessException":
2107
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2108
- case "InvalidInputException":
2109
- case "com.amazonaws.securityhub#InvalidInputException":
2110
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2111
- case "LimitExceededException":
2112
- case "com.amazonaws.securityhub#LimitExceededException":
2113
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2114
- case "ResourceNotFoundException":
2115
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2116
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2117
- default:
2118
- const parsedBody = parsedOutput.body;
2119
- return throwDefaultError({
2120
- output,
2121
- parsedBody,
2122
- errorCode,
2123
- });
2124
- }
2125
- };
2126
1379
  export const de_DeleteInvitationsCommand = async (output, context) => {
2127
1380
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2128
- return de_DeleteInvitationsCommandError(output, context);
1381
+ return de_CommandError(output, context);
2129
1382
  }
2130
1383
  const contents = map({
2131
1384
  $metadata: deserializeMetadata(output),
@@ -2137,40 +1390,9 @@ export const de_DeleteInvitationsCommand = async (output, context) => {
2137
1390
  Object.assign(contents, doc);
2138
1391
  return contents;
2139
1392
  };
2140
- const de_DeleteInvitationsCommandError = async (output, context) => {
2141
- const parsedOutput = {
2142
- ...output,
2143
- body: await parseErrorBody(output.body, context),
2144
- };
2145
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2146
- switch (errorCode) {
2147
- case "InternalException":
2148
- case "com.amazonaws.securityhub#InternalException":
2149
- throw await de_InternalExceptionRes(parsedOutput, context);
2150
- case "InvalidAccessException":
2151
- case "com.amazonaws.securityhub#InvalidAccessException":
2152
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2153
- case "InvalidInputException":
2154
- case "com.amazonaws.securityhub#InvalidInputException":
2155
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2156
- case "LimitExceededException":
2157
- case "com.amazonaws.securityhub#LimitExceededException":
2158
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2159
- case "ResourceNotFoundException":
2160
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2161
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2162
- default:
2163
- const parsedBody = parsedOutput.body;
2164
- return throwDefaultError({
2165
- output,
2166
- parsedBody,
2167
- errorCode,
2168
- });
2169
- }
2170
- };
2171
1393
  export const de_DeleteMembersCommand = async (output, context) => {
2172
1394
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2173
- return de_DeleteMembersCommandError(output, context);
1395
+ return de_CommandError(output, context);
2174
1396
  }
2175
1397
  const contents = map({
2176
1398
  $metadata: deserializeMetadata(output),
@@ -2182,40 +1404,9 @@ export const de_DeleteMembersCommand = async (output, context) => {
2182
1404
  Object.assign(contents, doc);
2183
1405
  return contents;
2184
1406
  };
2185
- const de_DeleteMembersCommandError = async (output, context) => {
2186
- const parsedOutput = {
2187
- ...output,
2188
- body: await parseErrorBody(output.body, context),
2189
- };
2190
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2191
- switch (errorCode) {
2192
- case "InternalException":
2193
- case "com.amazonaws.securityhub#InternalException":
2194
- throw await de_InternalExceptionRes(parsedOutput, context);
2195
- case "InvalidAccessException":
2196
- case "com.amazonaws.securityhub#InvalidAccessException":
2197
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2198
- case "InvalidInputException":
2199
- case "com.amazonaws.securityhub#InvalidInputException":
2200
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2201
- case "LimitExceededException":
2202
- case "com.amazonaws.securityhub#LimitExceededException":
2203
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2204
- case "ResourceNotFoundException":
2205
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2206
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2207
- default:
2208
- const parsedBody = parsedOutput.body;
2209
- return throwDefaultError({
2210
- output,
2211
- parsedBody,
2212
- errorCode,
2213
- });
2214
- }
2215
- };
2216
1407
  export const de_DescribeActionTargetsCommand = async (output, context) => {
2217
1408
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2218
- return de_DescribeActionTargetsCommandError(output, context);
1409
+ return de_CommandError(output, context);
2219
1410
  }
2220
1411
  const contents = map({
2221
1412
  $metadata: deserializeMetadata(output),
@@ -2228,37 +1419,9 @@ export const de_DescribeActionTargetsCommand = async (output, context) => {
2228
1419
  Object.assign(contents, doc);
2229
1420
  return contents;
2230
1421
  };
2231
- const de_DescribeActionTargetsCommandError = async (output, context) => {
2232
- const parsedOutput = {
2233
- ...output,
2234
- body: await parseErrorBody(output.body, context),
2235
- };
2236
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2237
- switch (errorCode) {
2238
- case "InternalException":
2239
- case "com.amazonaws.securityhub#InternalException":
2240
- throw await de_InternalExceptionRes(parsedOutput, context);
2241
- case "InvalidAccessException":
2242
- case "com.amazonaws.securityhub#InvalidAccessException":
2243
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2244
- case "InvalidInputException":
2245
- case "com.amazonaws.securityhub#InvalidInputException":
2246
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2247
- case "ResourceNotFoundException":
2248
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2249
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2250
- default:
2251
- const parsedBody = parsedOutput.body;
2252
- return throwDefaultError({
2253
- output,
2254
- parsedBody,
2255
- errorCode,
2256
- });
2257
- }
2258
- };
2259
1422
  export const de_DescribeHubCommand = async (output, context) => {
2260
1423
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2261
- return de_DescribeHubCommandError(output, context);
1424
+ return de_CommandError(output, context);
2262
1425
  }
2263
1426
  const contents = map({
2264
1427
  $metadata: deserializeMetadata(output),
@@ -2273,40 +1436,9 @@ export const de_DescribeHubCommand = async (output, context) => {
2273
1436
  Object.assign(contents, doc);
2274
1437
  return contents;
2275
1438
  };
2276
- const de_DescribeHubCommandError = async (output, context) => {
2277
- const parsedOutput = {
2278
- ...output,
2279
- body: await parseErrorBody(output.body, context),
2280
- };
2281
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2282
- switch (errorCode) {
2283
- case "InternalException":
2284
- case "com.amazonaws.securityhub#InternalException":
2285
- throw await de_InternalExceptionRes(parsedOutput, context);
2286
- case "InvalidAccessException":
2287
- case "com.amazonaws.securityhub#InvalidAccessException":
2288
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2289
- case "InvalidInputException":
2290
- case "com.amazonaws.securityhub#InvalidInputException":
2291
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2292
- case "LimitExceededException":
2293
- case "com.amazonaws.securityhub#LimitExceededException":
2294
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2295
- case "ResourceNotFoundException":
2296
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2297
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2298
- default:
2299
- const parsedBody = parsedOutput.body;
2300
- return throwDefaultError({
2301
- output,
2302
- parsedBody,
2303
- errorCode,
2304
- });
2305
- }
2306
- };
2307
1439
  export const de_DescribeOrganizationConfigurationCommand = async (output, context) => {
2308
1440
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2309
- return de_DescribeOrganizationConfigurationCommandError(output, context);
1441
+ return de_CommandError(output, context);
2310
1442
  }
2311
1443
  const contents = map({
2312
1444
  $metadata: deserializeMetadata(output),
@@ -2321,37 +1453,9 @@ export const de_DescribeOrganizationConfigurationCommand = async (output, contex
2321
1453
  Object.assign(contents, doc);
2322
1454
  return contents;
2323
1455
  };
2324
- const de_DescribeOrganizationConfigurationCommandError = async (output, context) => {
2325
- const parsedOutput = {
2326
- ...output,
2327
- body: await parseErrorBody(output.body, context),
2328
- };
2329
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2330
- switch (errorCode) {
2331
- case "InternalException":
2332
- case "com.amazonaws.securityhub#InternalException":
2333
- throw await de_InternalExceptionRes(parsedOutput, context);
2334
- case "InvalidAccessException":
2335
- case "com.amazonaws.securityhub#InvalidAccessException":
2336
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2337
- case "InvalidInputException":
2338
- case "com.amazonaws.securityhub#InvalidInputException":
2339
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2340
- case "LimitExceededException":
2341
- case "com.amazonaws.securityhub#LimitExceededException":
2342
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2343
- default:
2344
- const parsedBody = parsedOutput.body;
2345
- return throwDefaultError({
2346
- output,
2347
- parsedBody,
2348
- errorCode,
2349
- });
2350
- }
2351
- };
2352
1456
  export const de_DescribeProductsCommand = async (output, context) => {
2353
1457
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2354
- return de_DescribeProductsCommandError(output, context);
1458
+ return de_CommandError(output, context);
2355
1459
  }
2356
1460
  const contents = map({
2357
1461
  $metadata: deserializeMetadata(output),
@@ -2364,37 +1468,9 @@ export const de_DescribeProductsCommand = async (output, context) => {
2364
1468
  Object.assign(contents, doc);
2365
1469
  return contents;
2366
1470
  };
2367
- const de_DescribeProductsCommandError = async (output, context) => {
2368
- const parsedOutput = {
2369
- ...output,
2370
- body: await parseErrorBody(output.body, context),
2371
- };
2372
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2373
- switch (errorCode) {
2374
- case "InternalException":
2375
- case "com.amazonaws.securityhub#InternalException":
2376
- throw await de_InternalExceptionRes(parsedOutput, context);
2377
- case "InvalidAccessException":
2378
- case "com.amazonaws.securityhub#InvalidAccessException":
2379
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2380
- case "InvalidInputException":
2381
- case "com.amazonaws.securityhub#InvalidInputException":
2382
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2383
- case "LimitExceededException":
2384
- case "com.amazonaws.securityhub#LimitExceededException":
2385
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2386
- default:
2387
- const parsedBody = parsedOutput.body;
2388
- return throwDefaultError({
2389
- output,
2390
- parsedBody,
2391
- errorCode,
2392
- });
2393
- }
2394
- };
2395
1471
  export const de_DescribeStandardsCommand = async (output, context) => {
2396
1472
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2397
- return de_DescribeStandardsCommandError(output, context);
1473
+ return de_CommandError(output, context);
2398
1474
  }
2399
1475
  const contents = map({
2400
1476
  $metadata: deserializeMetadata(output),
@@ -2407,34 +1483,9 @@ export const de_DescribeStandardsCommand = async (output, context) => {
2407
1483
  Object.assign(contents, doc);
2408
1484
  return contents;
2409
1485
  };
2410
- const de_DescribeStandardsCommandError = async (output, context) => {
2411
- const parsedOutput = {
2412
- ...output,
2413
- body: await parseErrorBody(output.body, context),
2414
- };
2415
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2416
- switch (errorCode) {
2417
- case "InternalException":
2418
- case "com.amazonaws.securityhub#InternalException":
2419
- throw await de_InternalExceptionRes(parsedOutput, context);
2420
- case "InvalidAccessException":
2421
- case "com.amazonaws.securityhub#InvalidAccessException":
2422
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2423
- case "InvalidInputException":
2424
- case "com.amazonaws.securityhub#InvalidInputException":
2425
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2426
- default:
2427
- const parsedBody = parsedOutput.body;
2428
- return throwDefaultError({
2429
- output,
2430
- parsedBody,
2431
- errorCode,
2432
- });
2433
- }
2434
- };
2435
1486
  export const de_DescribeStandardsControlsCommand = async (output, context) => {
2436
1487
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2437
- return de_DescribeStandardsControlsCommandError(output, context);
1488
+ return de_CommandError(output, context);
2438
1489
  }
2439
1490
  const contents = map({
2440
1491
  $metadata: deserializeMetadata(output),
@@ -2447,37 +1498,9 @@ export const de_DescribeStandardsControlsCommand = async (output, context) => {
2447
1498
  Object.assign(contents, doc);
2448
1499
  return contents;
2449
1500
  };
2450
- const de_DescribeStandardsControlsCommandError = async (output, context) => {
2451
- const parsedOutput = {
2452
- ...output,
2453
- body: await parseErrorBody(output.body, context),
2454
- };
2455
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2456
- switch (errorCode) {
2457
- case "InternalException":
2458
- case "com.amazonaws.securityhub#InternalException":
2459
- throw await de_InternalExceptionRes(parsedOutput, context);
2460
- case "InvalidAccessException":
2461
- case "com.amazonaws.securityhub#InvalidAccessException":
2462
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2463
- case "InvalidInputException":
2464
- case "com.amazonaws.securityhub#InvalidInputException":
2465
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2466
- case "ResourceNotFoundException":
2467
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2468
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2469
- default:
2470
- const parsedBody = parsedOutput.body;
2471
- return throwDefaultError({
2472
- output,
2473
- parsedBody,
2474
- errorCode,
2475
- });
2476
- }
2477
- };
2478
1501
  export const de_DisableImportFindingsForProductCommand = async (output, context) => {
2479
1502
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2480
- return de_DisableImportFindingsForProductCommandError(output, context);
1503
+ return de_CommandError(output, context);
2481
1504
  }
2482
1505
  const contents = map({
2483
1506
  $metadata: deserializeMetadata(output),
@@ -2485,40 +1508,19 @@ export const de_DisableImportFindingsForProductCommand = async (output, context)
2485
1508
  await collectBody(output.body, context);
2486
1509
  return contents;
2487
1510
  };
2488
- const de_DisableImportFindingsForProductCommandError = async (output, context) => {
2489
- const parsedOutput = {
2490
- ...output,
2491
- body: await parseErrorBody(output.body, context),
2492
- };
2493
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2494
- switch (errorCode) {
2495
- case "InternalException":
2496
- case "com.amazonaws.securityhub#InternalException":
2497
- throw await de_InternalExceptionRes(parsedOutput, context);
2498
- case "InvalidAccessException":
2499
- case "com.amazonaws.securityhub#InvalidAccessException":
2500
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2501
- case "InvalidInputException":
2502
- case "com.amazonaws.securityhub#InvalidInputException":
2503
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2504
- case "LimitExceededException":
2505
- case "com.amazonaws.securityhub#LimitExceededException":
2506
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2507
- case "ResourceNotFoundException":
2508
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2509
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2510
- default:
2511
- const parsedBody = parsedOutput.body;
2512
- return throwDefaultError({
2513
- output,
2514
- parsedBody,
2515
- errorCode,
2516
- });
1511
+ export const de_DisableOrganizationAdminAccountCommand = async (output, context) => {
1512
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1513
+ return de_CommandError(output, context);
2517
1514
  }
1515
+ const contents = map({
1516
+ $metadata: deserializeMetadata(output),
1517
+ });
1518
+ await collectBody(output.body, context);
1519
+ return contents;
2518
1520
  };
2519
- export const de_DisableOrganizationAdminAccountCommand = async (output, context) => {
1521
+ export const de_DisableSecurityHubCommand = async (output, context) => {
2520
1522
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2521
- return de_DisableOrganizationAdminAccountCommandError(output, context);
1523
+ return de_CommandError(output, context);
2522
1524
  }
2523
1525
  const contents = map({
2524
1526
  $metadata: deserializeMetadata(output),
@@ -2526,40 +1528,19 @@ export const de_DisableOrganizationAdminAccountCommand = async (output, context)
2526
1528
  await collectBody(output.body, context);
2527
1529
  return contents;
2528
1530
  };
2529
- const de_DisableOrganizationAdminAccountCommandError = async (output, context) => {
2530
- const parsedOutput = {
2531
- ...output,
2532
- body: await parseErrorBody(output.body, context),
2533
- };
2534
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2535
- switch (errorCode) {
2536
- case "AccessDeniedException":
2537
- case "com.amazonaws.securityhub#AccessDeniedException":
2538
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2539
- case "InternalException":
2540
- case "com.amazonaws.securityhub#InternalException":
2541
- throw await de_InternalExceptionRes(parsedOutput, context);
2542
- case "InvalidAccessException":
2543
- case "com.amazonaws.securityhub#InvalidAccessException":
2544
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2545
- case "InvalidInputException":
2546
- case "com.amazonaws.securityhub#InvalidInputException":
2547
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2548
- case "LimitExceededException":
2549
- case "com.amazonaws.securityhub#LimitExceededException":
2550
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2551
- default:
2552
- const parsedBody = parsedOutput.body;
2553
- return throwDefaultError({
2554
- output,
2555
- parsedBody,
2556
- errorCode,
2557
- });
1531
+ export const de_DisassociateFromAdministratorAccountCommand = async (output, context) => {
1532
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1533
+ return de_CommandError(output, context);
2558
1534
  }
1535
+ const contents = map({
1536
+ $metadata: deserializeMetadata(output),
1537
+ });
1538
+ await collectBody(output.body, context);
1539
+ return contents;
2559
1540
  };
2560
- export const de_DisableSecurityHubCommand = async (output, context) => {
1541
+ export const de_DisassociateFromMasterAccountCommand = async (output, context) => {
2561
1542
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2562
- return de_DisableSecurityHubCommandError(output, context);
1543
+ return de_CommandError(output, context);
2563
1544
  }
2564
1545
  const contents = map({
2565
1546
  $metadata: deserializeMetadata(output),
@@ -2567,122 +1548,9 @@ export const de_DisableSecurityHubCommand = async (output, context) => {
2567
1548
  await collectBody(output.body, context);
2568
1549
  return contents;
2569
1550
  };
2570
- const de_DisableSecurityHubCommandError = async (output, context) => {
2571
- const parsedOutput = {
2572
- ...output,
2573
- body: await parseErrorBody(output.body, context),
2574
- };
2575
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2576
- switch (errorCode) {
2577
- case "AccessDeniedException":
2578
- case "com.amazonaws.securityhub#AccessDeniedException":
2579
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2580
- case "InternalException":
2581
- case "com.amazonaws.securityhub#InternalException":
2582
- throw await de_InternalExceptionRes(parsedOutput, context);
2583
- case "InvalidAccessException":
2584
- case "com.amazonaws.securityhub#InvalidAccessException":
2585
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2586
- case "LimitExceededException":
2587
- case "com.amazonaws.securityhub#LimitExceededException":
2588
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2589
- case "ResourceNotFoundException":
2590
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2591
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2592
- default:
2593
- const parsedBody = parsedOutput.body;
2594
- return throwDefaultError({
2595
- output,
2596
- parsedBody,
2597
- errorCode,
2598
- });
2599
- }
2600
- };
2601
- export const de_DisassociateFromAdministratorAccountCommand = async (output, context) => {
2602
- if (output.statusCode !== 200 && output.statusCode >= 300) {
2603
- return de_DisassociateFromAdministratorAccountCommandError(output, context);
2604
- }
2605
- const contents = map({
2606
- $metadata: deserializeMetadata(output),
2607
- });
2608
- await collectBody(output.body, context);
2609
- return contents;
2610
- };
2611
- const de_DisassociateFromAdministratorAccountCommandError = async (output, context) => {
2612
- const parsedOutput = {
2613
- ...output,
2614
- body: await parseErrorBody(output.body, context),
2615
- };
2616
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2617
- switch (errorCode) {
2618
- case "InternalException":
2619
- case "com.amazonaws.securityhub#InternalException":
2620
- throw await de_InternalExceptionRes(parsedOutput, context);
2621
- case "InvalidAccessException":
2622
- case "com.amazonaws.securityhub#InvalidAccessException":
2623
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2624
- case "InvalidInputException":
2625
- case "com.amazonaws.securityhub#InvalidInputException":
2626
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2627
- case "LimitExceededException":
2628
- case "com.amazonaws.securityhub#LimitExceededException":
2629
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2630
- case "ResourceNotFoundException":
2631
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2632
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2633
- default:
2634
- const parsedBody = parsedOutput.body;
2635
- return throwDefaultError({
2636
- output,
2637
- parsedBody,
2638
- errorCode,
2639
- });
2640
- }
2641
- };
2642
- export const de_DisassociateFromMasterAccountCommand = async (output, context) => {
2643
- if (output.statusCode !== 200 && output.statusCode >= 300) {
2644
- return de_DisassociateFromMasterAccountCommandError(output, context);
2645
- }
2646
- const contents = map({
2647
- $metadata: deserializeMetadata(output),
2648
- });
2649
- await collectBody(output.body, context);
2650
- return contents;
2651
- };
2652
- const de_DisassociateFromMasterAccountCommandError = async (output, context) => {
2653
- const parsedOutput = {
2654
- ...output,
2655
- body: await parseErrorBody(output.body, context),
2656
- };
2657
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2658
- switch (errorCode) {
2659
- case "InternalException":
2660
- case "com.amazonaws.securityhub#InternalException":
2661
- throw await de_InternalExceptionRes(parsedOutput, context);
2662
- case "InvalidAccessException":
2663
- case "com.amazonaws.securityhub#InvalidAccessException":
2664
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2665
- case "InvalidInputException":
2666
- case "com.amazonaws.securityhub#InvalidInputException":
2667
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2668
- case "LimitExceededException":
2669
- case "com.amazonaws.securityhub#LimitExceededException":
2670
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2671
- case "ResourceNotFoundException":
2672
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2673
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2674
- default:
2675
- const parsedBody = parsedOutput.body;
2676
- return throwDefaultError({
2677
- output,
2678
- parsedBody,
2679
- errorCode,
2680
- });
2681
- }
2682
- };
2683
1551
  export const de_DisassociateMembersCommand = async (output, context) => {
2684
1552
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2685
- return de_DisassociateMembersCommandError(output, context);
1553
+ return de_CommandError(output, context);
2686
1554
  }
2687
1555
  const contents = map({
2688
1556
  $metadata: deserializeMetadata(output),
@@ -2690,43 +1558,9 @@ export const de_DisassociateMembersCommand = async (output, context) => {
2690
1558
  await collectBody(output.body, context);
2691
1559
  return contents;
2692
1560
  };
2693
- const de_DisassociateMembersCommandError = async (output, context) => {
2694
- const parsedOutput = {
2695
- ...output,
2696
- body: await parseErrorBody(output.body, context),
2697
- };
2698
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2699
- switch (errorCode) {
2700
- case "AccessDeniedException":
2701
- case "com.amazonaws.securityhub#AccessDeniedException":
2702
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2703
- case "InternalException":
2704
- case "com.amazonaws.securityhub#InternalException":
2705
- throw await de_InternalExceptionRes(parsedOutput, context);
2706
- case "InvalidAccessException":
2707
- case "com.amazonaws.securityhub#InvalidAccessException":
2708
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2709
- case "InvalidInputException":
2710
- case "com.amazonaws.securityhub#InvalidInputException":
2711
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2712
- case "LimitExceededException":
2713
- case "com.amazonaws.securityhub#LimitExceededException":
2714
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2715
- case "ResourceNotFoundException":
2716
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2717
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2718
- default:
2719
- const parsedBody = parsedOutput.body;
2720
- return throwDefaultError({
2721
- output,
2722
- parsedBody,
2723
- errorCode,
2724
- });
2725
- }
2726
- };
2727
1561
  export const de_EnableImportFindingsForProductCommand = async (output, context) => {
2728
1562
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2729
- return de_EnableImportFindingsForProductCommandError(output, context);
1563
+ return de_CommandError(output, context);
2730
1564
  }
2731
1565
  const contents = map({
2732
1566
  $metadata: deserializeMetadata(output),
@@ -2738,40 +1572,9 @@ export const de_EnableImportFindingsForProductCommand = async (output, context)
2738
1572
  Object.assign(contents, doc);
2739
1573
  return contents;
2740
1574
  };
2741
- const de_EnableImportFindingsForProductCommandError = async (output, context) => {
2742
- const parsedOutput = {
2743
- ...output,
2744
- body: await parseErrorBody(output.body, context),
2745
- };
2746
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2747
- switch (errorCode) {
2748
- case "InternalException":
2749
- case "com.amazonaws.securityhub#InternalException":
2750
- throw await de_InternalExceptionRes(parsedOutput, context);
2751
- case "InvalidAccessException":
2752
- case "com.amazonaws.securityhub#InvalidAccessException":
2753
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2754
- case "InvalidInputException":
2755
- case "com.amazonaws.securityhub#InvalidInputException":
2756
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2757
- case "LimitExceededException":
2758
- case "com.amazonaws.securityhub#LimitExceededException":
2759
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2760
- case "ResourceConflictException":
2761
- case "com.amazonaws.securityhub#ResourceConflictException":
2762
- throw await de_ResourceConflictExceptionRes(parsedOutput, context);
2763
- default:
2764
- const parsedBody = parsedOutput.body;
2765
- return throwDefaultError({
2766
- output,
2767
- parsedBody,
2768
- errorCode,
2769
- });
2770
- }
2771
- };
2772
1575
  export const de_EnableOrganizationAdminAccountCommand = async (output, context) => {
2773
1576
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2774
- return de_EnableOrganizationAdminAccountCommandError(output, context);
1577
+ return de_CommandError(output, context);
2775
1578
  }
2776
1579
  const contents = map({
2777
1580
  $metadata: deserializeMetadata(output),
@@ -2779,40 +1582,9 @@ export const de_EnableOrganizationAdminAccountCommand = async (output, context)
2779
1582
  await collectBody(output.body, context);
2780
1583
  return contents;
2781
1584
  };
2782
- const de_EnableOrganizationAdminAccountCommandError = async (output, context) => {
2783
- const parsedOutput = {
2784
- ...output,
2785
- body: await parseErrorBody(output.body, context),
2786
- };
2787
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2788
- switch (errorCode) {
2789
- case "AccessDeniedException":
2790
- case "com.amazonaws.securityhub#AccessDeniedException":
2791
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2792
- case "InternalException":
2793
- case "com.amazonaws.securityhub#InternalException":
2794
- throw await de_InternalExceptionRes(parsedOutput, context);
2795
- case "InvalidAccessException":
2796
- case "com.amazonaws.securityhub#InvalidAccessException":
2797
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2798
- case "InvalidInputException":
2799
- case "com.amazonaws.securityhub#InvalidInputException":
2800
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2801
- case "LimitExceededException":
2802
- case "com.amazonaws.securityhub#LimitExceededException":
2803
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2804
- default:
2805
- const parsedBody = parsedOutput.body;
2806
- return throwDefaultError({
2807
- output,
2808
- parsedBody,
2809
- errorCode,
2810
- });
2811
- }
2812
- };
2813
1585
  export const de_EnableSecurityHubCommand = async (output, context) => {
2814
1586
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2815
- return de_EnableSecurityHubCommandError(output, context);
1587
+ return de_CommandError(output, context);
2816
1588
  }
2817
1589
  const contents = map({
2818
1590
  $metadata: deserializeMetadata(output),
@@ -2820,40 +1592,9 @@ export const de_EnableSecurityHubCommand = async (output, context) => {
2820
1592
  await collectBody(output.body, context);
2821
1593
  return contents;
2822
1594
  };
2823
- const de_EnableSecurityHubCommandError = async (output, context) => {
2824
- const parsedOutput = {
2825
- ...output,
2826
- body: await parseErrorBody(output.body, context),
2827
- };
2828
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2829
- switch (errorCode) {
2830
- case "AccessDeniedException":
2831
- case "com.amazonaws.securityhub#AccessDeniedException":
2832
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2833
- case "InternalException":
2834
- case "com.amazonaws.securityhub#InternalException":
2835
- throw await de_InternalExceptionRes(parsedOutput, context);
2836
- case "InvalidAccessException":
2837
- case "com.amazonaws.securityhub#InvalidAccessException":
2838
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2839
- case "LimitExceededException":
2840
- case "com.amazonaws.securityhub#LimitExceededException":
2841
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2842
- case "ResourceConflictException":
2843
- case "com.amazonaws.securityhub#ResourceConflictException":
2844
- throw await de_ResourceConflictExceptionRes(parsedOutput, context);
2845
- default:
2846
- const parsedBody = parsedOutput.body;
2847
- return throwDefaultError({
2848
- output,
2849
- parsedBody,
2850
- errorCode,
2851
- });
2852
- }
2853
- };
2854
1595
  export const de_GetAdministratorAccountCommand = async (output, context) => {
2855
1596
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2856
- return de_GetAdministratorAccountCommandError(output, context);
1597
+ return de_CommandError(output, context);
2857
1598
  }
2858
1599
  const contents = map({
2859
1600
  $metadata: deserializeMetadata(output),
@@ -2865,40 +1606,9 @@ export const de_GetAdministratorAccountCommand = async (output, context) => {
2865
1606
  Object.assign(contents, doc);
2866
1607
  return contents;
2867
1608
  };
2868
- const de_GetAdministratorAccountCommandError = async (output, context) => {
2869
- const parsedOutput = {
2870
- ...output,
2871
- body: await parseErrorBody(output.body, context),
2872
- };
2873
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2874
- switch (errorCode) {
2875
- case "InternalException":
2876
- case "com.amazonaws.securityhub#InternalException":
2877
- throw await de_InternalExceptionRes(parsedOutput, context);
2878
- case "InvalidAccessException":
2879
- case "com.amazonaws.securityhub#InvalidAccessException":
2880
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2881
- case "InvalidInputException":
2882
- case "com.amazonaws.securityhub#InvalidInputException":
2883
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2884
- case "LimitExceededException":
2885
- case "com.amazonaws.securityhub#LimitExceededException":
2886
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2887
- case "ResourceNotFoundException":
2888
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2889
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2890
- default:
2891
- const parsedBody = parsedOutput.body;
2892
- return throwDefaultError({
2893
- output,
2894
- parsedBody,
2895
- errorCode,
2896
- });
2897
- }
2898
- };
2899
1609
  export const de_GetConfigurationPolicyCommand = async (output, context) => {
2900
1610
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2901
- return de_GetConfigurationPolicyCommandError(output, context);
1611
+ return de_CommandError(output, context);
2902
1612
  }
2903
1613
  const contents = map({
2904
1614
  $metadata: deserializeMetadata(output),
@@ -2916,43 +1626,9 @@ export const de_GetConfigurationPolicyCommand = async (output, context) => {
2916
1626
  Object.assign(contents, doc);
2917
1627
  return contents;
2918
1628
  };
2919
- const de_GetConfigurationPolicyCommandError = async (output, context) => {
2920
- const parsedOutput = {
2921
- ...output,
2922
- body: await parseErrorBody(output.body, context),
2923
- };
2924
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2925
- switch (errorCode) {
2926
- case "AccessDeniedException":
2927
- case "com.amazonaws.securityhub#AccessDeniedException":
2928
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2929
- case "InternalException":
2930
- case "com.amazonaws.securityhub#InternalException":
2931
- throw await de_InternalExceptionRes(parsedOutput, context);
2932
- case "InvalidAccessException":
2933
- case "com.amazonaws.securityhub#InvalidAccessException":
2934
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2935
- case "InvalidInputException":
2936
- case "com.amazonaws.securityhub#InvalidInputException":
2937
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2938
- case "LimitExceededException":
2939
- case "com.amazonaws.securityhub#LimitExceededException":
2940
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2941
- case "ResourceNotFoundException":
2942
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2943
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2944
- default:
2945
- const parsedBody = parsedOutput.body;
2946
- return throwDefaultError({
2947
- output,
2948
- parsedBody,
2949
- errorCode,
2950
- });
2951
- }
2952
- };
2953
1629
  export const de_GetConfigurationPolicyAssociationCommand = async (output, context) => {
2954
1630
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2955
- return de_GetConfigurationPolicyAssociationCommandError(output, context);
1631
+ return de_CommandError(output, context);
2956
1632
  }
2957
1633
  const contents = map({
2958
1634
  $metadata: deserializeMetadata(output),
@@ -2960,547 +1636,181 @@ export const de_GetConfigurationPolicyAssociationCommand = async (output, contex
2960
1636
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
2961
1637
  const doc = take(data, {
2962
1638
  AssociationStatus: __expectString,
2963
- AssociationStatusMessage: __expectString,
2964
- AssociationType: __expectString,
2965
- ConfigurationPolicyId: __expectString,
2966
- TargetId: __expectString,
2967
- TargetType: __expectString,
2968
- UpdatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
2969
- });
2970
- Object.assign(contents, doc);
2971
- return contents;
2972
- };
2973
- const de_GetConfigurationPolicyAssociationCommandError = async (output, context) => {
2974
- const parsedOutput = {
2975
- ...output,
2976
- body: await parseErrorBody(output.body, context),
2977
- };
2978
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2979
- switch (errorCode) {
2980
- case "AccessDeniedException":
2981
- case "com.amazonaws.securityhub#AccessDeniedException":
2982
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2983
- case "InternalException":
2984
- case "com.amazonaws.securityhub#InternalException":
2985
- throw await de_InternalExceptionRes(parsedOutput, context);
2986
- case "InvalidAccessException":
2987
- case "com.amazonaws.securityhub#InvalidAccessException":
2988
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
2989
- case "InvalidInputException":
2990
- case "com.amazonaws.securityhub#InvalidInputException":
2991
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
2992
- case "LimitExceededException":
2993
- case "com.amazonaws.securityhub#LimitExceededException":
2994
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2995
- case "ResourceNotFoundException":
2996
- case "com.amazonaws.securityhub#ResourceNotFoundException":
2997
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2998
- default:
2999
- const parsedBody = parsedOutput.body;
3000
- return throwDefaultError({
3001
- output,
3002
- parsedBody,
3003
- errorCode,
3004
- });
3005
- }
3006
- };
3007
- export const de_GetEnabledStandardsCommand = async (output, context) => {
3008
- if (output.statusCode !== 200 && output.statusCode >= 300) {
3009
- return de_GetEnabledStandardsCommandError(output, context);
3010
- }
3011
- const contents = map({
3012
- $metadata: deserializeMetadata(output),
3013
- });
3014
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3015
- const doc = take(data, {
3016
- NextToken: __expectString,
3017
- StandardsSubscriptions: _json,
3018
- });
3019
- Object.assign(contents, doc);
3020
- return contents;
3021
- };
3022
- const de_GetEnabledStandardsCommandError = async (output, context) => {
3023
- const parsedOutput = {
3024
- ...output,
3025
- body: await parseErrorBody(output.body, context),
3026
- };
3027
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3028
- switch (errorCode) {
3029
- case "InternalException":
3030
- case "com.amazonaws.securityhub#InternalException":
3031
- throw await de_InternalExceptionRes(parsedOutput, context);
3032
- case "InvalidAccessException":
3033
- case "com.amazonaws.securityhub#InvalidAccessException":
3034
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3035
- case "InvalidInputException":
3036
- case "com.amazonaws.securityhub#InvalidInputException":
3037
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3038
- case "LimitExceededException":
3039
- case "com.amazonaws.securityhub#LimitExceededException":
3040
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3041
- default:
3042
- const parsedBody = parsedOutput.body;
3043
- return throwDefaultError({
3044
- output,
3045
- parsedBody,
3046
- errorCode,
3047
- });
3048
- }
3049
- };
3050
- export const de_GetFindingAggregatorCommand = async (output, context) => {
3051
- if (output.statusCode !== 200 && output.statusCode >= 300) {
3052
- return de_GetFindingAggregatorCommandError(output, context);
3053
- }
3054
- const contents = map({
3055
- $metadata: deserializeMetadata(output),
3056
- });
3057
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3058
- const doc = take(data, {
3059
- FindingAggregationRegion: __expectString,
3060
- FindingAggregatorArn: __expectString,
3061
- RegionLinkingMode: __expectString,
3062
- Regions: _json,
3063
- });
3064
- Object.assign(contents, doc);
3065
- return contents;
3066
- };
3067
- const de_GetFindingAggregatorCommandError = async (output, context) => {
3068
- const parsedOutput = {
3069
- ...output,
3070
- body: await parseErrorBody(output.body, context),
3071
- };
3072
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3073
- switch (errorCode) {
3074
- case "AccessDeniedException":
3075
- case "com.amazonaws.securityhub#AccessDeniedException":
3076
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3077
- case "InternalException":
3078
- case "com.amazonaws.securityhub#InternalException":
3079
- throw await de_InternalExceptionRes(parsedOutput, context);
3080
- case "InvalidAccessException":
3081
- case "com.amazonaws.securityhub#InvalidAccessException":
3082
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3083
- case "InvalidInputException":
3084
- case "com.amazonaws.securityhub#InvalidInputException":
3085
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3086
- case "LimitExceededException":
3087
- case "com.amazonaws.securityhub#LimitExceededException":
3088
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3089
- case "ResourceNotFoundException":
3090
- case "com.amazonaws.securityhub#ResourceNotFoundException":
3091
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3092
- default:
3093
- const parsedBody = parsedOutput.body;
3094
- return throwDefaultError({
3095
- output,
3096
- parsedBody,
3097
- errorCode,
3098
- });
3099
- }
3100
- };
3101
- export const de_GetFindingHistoryCommand = async (output, context) => {
3102
- if (output.statusCode !== 200 && output.statusCode >= 300) {
3103
- return de_GetFindingHistoryCommandError(output, context);
3104
- }
3105
- const contents = map({
3106
- $metadata: deserializeMetadata(output),
3107
- });
3108
- const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3109
- const doc = take(data, {
3110
- NextToken: __expectString,
3111
- Records: (_) => de_FindingHistoryRecordList(_, context),
3112
- });
3113
- Object.assign(contents, doc);
3114
- return contents;
3115
- };
3116
- const de_GetFindingHistoryCommandError = async (output, context) => {
3117
- const parsedOutput = {
3118
- ...output,
3119
- body: await parseErrorBody(output.body, context),
3120
- };
3121
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3122
- switch (errorCode) {
3123
- case "InternalException":
3124
- case "com.amazonaws.securityhub#InternalException":
3125
- throw await de_InternalExceptionRes(parsedOutput, context);
3126
- case "InvalidAccessException":
3127
- case "com.amazonaws.securityhub#InvalidAccessException":
3128
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3129
- case "InvalidInputException":
3130
- case "com.amazonaws.securityhub#InvalidInputException":
3131
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3132
- case "LimitExceededException":
3133
- case "com.amazonaws.securityhub#LimitExceededException":
3134
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3135
- default:
3136
- const parsedBody = parsedOutput.body;
3137
- return throwDefaultError({
3138
- output,
3139
- parsedBody,
3140
- errorCode,
3141
- });
3142
- }
1639
+ AssociationStatusMessage: __expectString,
1640
+ AssociationType: __expectString,
1641
+ ConfigurationPolicyId: __expectString,
1642
+ TargetId: __expectString,
1643
+ TargetType: __expectString,
1644
+ UpdatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
1645
+ });
1646
+ Object.assign(contents, doc);
1647
+ return contents;
3143
1648
  };
3144
- export const de_GetFindingsCommand = async (output, context) => {
1649
+ export const de_GetEnabledStandardsCommand = async (output, context) => {
3145
1650
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3146
- return de_GetFindingsCommandError(output, context);
1651
+ return de_CommandError(output, context);
3147
1652
  }
3148
1653
  const contents = map({
3149
1654
  $metadata: deserializeMetadata(output),
3150
1655
  });
3151
1656
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3152
1657
  const doc = take(data, {
3153
- Findings: (_) => de_AwsSecurityFindingList(_, context),
3154
1658
  NextToken: __expectString,
1659
+ StandardsSubscriptions: _json,
3155
1660
  });
3156
1661
  Object.assign(contents, doc);
3157
1662
  return contents;
3158
1663
  };
3159
- const de_GetFindingsCommandError = async (output, context) => {
3160
- const parsedOutput = {
3161
- ...output,
3162
- body: await parseErrorBody(output.body, context),
3163
- };
3164
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3165
- switch (errorCode) {
3166
- case "InternalException":
3167
- case "com.amazonaws.securityhub#InternalException":
3168
- throw await de_InternalExceptionRes(parsedOutput, context);
3169
- case "InvalidAccessException":
3170
- case "com.amazonaws.securityhub#InvalidAccessException":
3171
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3172
- case "InvalidInputException":
3173
- case "com.amazonaws.securityhub#InvalidInputException":
3174
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3175
- case "LimitExceededException":
3176
- case "com.amazonaws.securityhub#LimitExceededException":
3177
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3178
- default:
3179
- const parsedBody = parsedOutput.body;
3180
- return throwDefaultError({
3181
- output,
3182
- parsedBody,
3183
- errorCode,
3184
- });
3185
- }
3186
- };
3187
- export const de_GetInsightResultsCommand = async (output, context) => {
1664
+ export const de_GetFindingAggregatorCommand = async (output, context) => {
3188
1665
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3189
- return de_GetInsightResultsCommandError(output, context);
1666
+ return de_CommandError(output, context);
3190
1667
  }
3191
1668
  const contents = map({
3192
1669
  $metadata: deserializeMetadata(output),
3193
1670
  });
3194
1671
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3195
1672
  const doc = take(data, {
3196
- InsightResults: _json,
1673
+ FindingAggregationRegion: __expectString,
1674
+ FindingAggregatorArn: __expectString,
1675
+ RegionLinkingMode: __expectString,
1676
+ Regions: _json,
3197
1677
  });
3198
1678
  Object.assign(contents, doc);
3199
1679
  return contents;
3200
1680
  };
3201
- const de_GetInsightResultsCommandError = async (output, context) => {
3202
- const parsedOutput = {
3203
- ...output,
3204
- body: await parseErrorBody(output.body, context),
3205
- };
3206
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3207
- switch (errorCode) {
3208
- case "InternalException":
3209
- case "com.amazonaws.securityhub#InternalException":
3210
- throw await de_InternalExceptionRes(parsedOutput, context);
3211
- case "InvalidAccessException":
3212
- case "com.amazonaws.securityhub#InvalidAccessException":
3213
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3214
- case "InvalidInputException":
3215
- case "com.amazonaws.securityhub#InvalidInputException":
3216
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3217
- case "LimitExceededException":
3218
- case "com.amazonaws.securityhub#LimitExceededException":
3219
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3220
- case "ResourceNotFoundException":
3221
- case "com.amazonaws.securityhub#ResourceNotFoundException":
3222
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3223
- default:
3224
- const parsedBody = parsedOutput.body;
3225
- return throwDefaultError({
3226
- output,
3227
- parsedBody,
3228
- errorCode,
3229
- });
3230
- }
3231
- };
3232
- export const de_GetInsightsCommand = async (output, context) => {
1681
+ export const de_GetFindingHistoryCommand = async (output, context) => {
3233
1682
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3234
- return de_GetInsightsCommandError(output, context);
1683
+ return de_CommandError(output, context);
3235
1684
  }
3236
1685
  const contents = map({
3237
1686
  $metadata: deserializeMetadata(output),
3238
1687
  });
3239
1688
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3240
1689
  const doc = take(data, {
3241
- Insights: (_) => de_InsightList(_, context),
3242
1690
  NextToken: __expectString,
1691
+ Records: (_) => de_FindingHistoryRecordList(_, context),
3243
1692
  });
3244
1693
  Object.assign(contents, doc);
3245
1694
  return contents;
3246
1695
  };
3247
- const de_GetInsightsCommandError = async (output, context) => {
3248
- const parsedOutput = {
3249
- ...output,
3250
- body: await parseErrorBody(output.body, context),
3251
- };
3252
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3253
- switch (errorCode) {
3254
- case "InternalException":
3255
- case "com.amazonaws.securityhub#InternalException":
3256
- throw await de_InternalExceptionRes(parsedOutput, context);
3257
- case "InvalidAccessException":
3258
- case "com.amazonaws.securityhub#InvalidAccessException":
3259
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3260
- case "InvalidInputException":
3261
- case "com.amazonaws.securityhub#InvalidInputException":
3262
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3263
- case "LimitExceededException":
3264
- case "com.amazonaws.securityhub#LimitExceededException":
3265
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3266
- case "ResourceNotFoundException":
3267
- case "com.amazonaws.securityhub#ResourceNotFoundException":
3268
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3269
- default:
3270
- const parsedBody = parsedOutput.body;
3271
- return throwDefaultError({
3272
- output,
3273
- parsedBody,
3274
- errorCode,
3275
- });
3276
- }
3277
- };
3278
- export const de_GetInvitationsCountCommand = async (output, context) => {
1696
+ export const de_GetFindingsCommand = async (output, context) => {
3279
1697
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3280
- return de_GetInvitationsCountCommandError(output, context);
1698
+ return de_CommandError(output, context);
3281
1699
  }
3282
1700
  const contents = map({
3283
1701
  $metadata: deserializeMetadata(output),
3284
1702
  });
3285
1703
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3286
1704
  const doc = take(data, {
3287
- InvitationsCount: __expectInt32,
1705
+ Findings: (_) => de_AwsSecurityFindingList(_, context),
1706
+ NextToken: __expectString,
3288
1707
  });
3289
1708
  Object.assign(contents, doc);
3290
1709
  return contents;
3291
1710
  };
3292
- const de_GetInvitationsCountCommandError = async (output, context) => {
3293
- const parsedOutput = {
3294
- ...output,
3295
- body: await parseErrorBody(output.body, context),
3296
- };
3297
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3298
- switch (errorCode) {
3299
- case "InternalException":
3300
- case "com.amazonaws.securityhub#InternalException":
3301
- throw await de_InternalExceptionRes(parsedOutput, context);
3302
- case "InvalidAccessException":
3303
- case "com.amazonaws.securityhub#InvalidAccessException":
3304
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3305
- case "InvalidInputException":
3306
- case "com.amazonaws.securityhub#InvalidInputException":
3307
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3308
- case "LimitExceededException":
3309
- case "com.amazonaws.securityhub#LimitExceededException":
3310
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3311
- default:
3312
- const parsedBody = parsedOutput.body;
3313
- return throwDefaultError({
3314
- output,
3315
- parsedBody,
3316
- errorCode,
3317
- });
3318
- }
3319
- };
3320
- export const de_GetMasterAccountCommand = async (output, context) => {
1711
+ export const de_GetInsightResultsCommand = async (output, context) => {
3321
1712
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3322
- return de_GetMasterAccountCommandError(output, context);
1713
+ return de_CommandError(output, context);
3323
1714
  }
3324
1715
  const contents = map({
3325
1716
  $metadata: deserializeMetadata(output),
3326
1717
  });
3327
1718
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3328
1719
  const doc = take(data, {
3329
- Master: (_) => de_Invitation(_, context),
1720
+ InsightResults: _json,
3330
1721
  });
3331
1722
  Object.assign(contents, doc);
3332
1723
  return contents;
3333
1724
  };
3334
- const de_GetMasterAccountCommandError = async (output, context) => {
3335
- const parsedOutput = {
3336
- ...output,
3337
- body: await parseErrorBody(output.body, context),
3338
- };
3339
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3340
- switch (errorCode) {
3341
- case "InternalException":
3342
- case "com.amazonaws.securityhub#InternalException":
3343
- throw await de_InternalExceptionRes(parsedOutput, context);
3344
- case "InvalidAccessException":
3345
- case "com.amazonaws.securityhub#InvalidAccessException":
3346
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3347
- case "InvalidInputException":
3348
- case "com.amazonaws.securityhub#InvalidInputException":
3349
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3350
- case "LimitExceededException":
3351
- case "com.amazonaws.securityhub#LimitExceededException":
3352
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3353
- case "ResourceNotFoundException":
3354
- case "com.amazonaws.securityhub#ResourceNotFoundException":
3355
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3356
- default:
3357
- const parsedBody = parsedOutput.body;
3358
- return throwDefaultError({
3359
- output,
3360
- parsedBody,
3361
- errorCode,
3362
- });
3363
- }
3364
- };
3365
- export const de_GetMembersCommand = async (output, context) => {
1725
+ export const de_GetInsightsCommand = async (output, context) => {
3366
1726
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3367
- return de_GetMembersCommandError(output, context);
1727
+ return de_CommandError(output, context);
3368
1728
  }
3369
1729
  const contents = map({
3370
1730
  $metadata: deserializeMetadata(output),
3371
1731
  });
3372
1732
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3373
1733
  const doc = take(data, {
3374
- Members: (_) => de_MemberList(_, context),
3375
- UnprocessedAccounts: _json,
1734
+ Insights: (_) => de_InsightList(_, context),
1735
+ NextToken: __expectString,
3376
1736
  });
3377
1737
  Object.assign(contents, doc);
3378
1738
  return contents;
3379
1739
  };
3380
- const de_GetMembersCommandError = async (output, context) => {
3381
- const parsedOutput = {
3382
- ...output,
3383
- body: await parseErrorBody(output.body, context),
3384
- };
3385
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3386
- switch (errorCode) {
3387
- case "InternalException":
3388
- case "com.amazonaws.securityhub#InternalException":
3389
- throw await de_InternalExceptionRes(parsedOutput, context);
3390
- case "InvalidAccessException":
3391
- case "com.amazonaws.securityhub#InvalidAccessException":
3392
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3393
- case "InvalidInputException":
3394
- case "com.amazonaws.securityhub#InvalidInputException":
3395
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3396
- case "LimitExceededException":
3397
- case "com.amazonaws.securityhub#LimitExceededException":
3398
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3399
- case "ResourceNotFoundException":
3400
- case "com.amazonaws.securityhub#ResourceNotFoundException":
3401
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3402
- default:
3403
- const parsedBody = parsedOutput.body;
3404
- return throwDefaultError({
3405
- output,
3406
- parsedBody,
3407
- errorCode,
3408
- });
3409
- }
3410
- };
3411
- export const de_GetSecurityControlDefinitionCommand = async (output, context) => {
1740
+ export const de_GetInvitationsCountCommand = async (output, context) => {
3412
1741
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3413
- return de_GetSecurityControlDefinitionCommandError(output, context);
1742
+ return de_CommandError(output, context);
3414
1743
  }
3415
1744
  const contents = map({
3416
1745
  $metadata: deserializeMetadata(output),
3417
1746
  });
3418
1747
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3419
1748
  const doc = take(data, {
3420
- SecurityControlDefinition: (_) => de_SecurityControlDefinition(_, context),
1749
+ InvitationsCount: __expectInt32,
3421
1750
  });
3422
1751
  Object.assign(contents, doc);
3423
1752
  return contents;
3424
1753
  };
3425
- const de_GetSecurityControlDefinitionCommandError = async (output, context) => {
3426
- const parsedOutput = {
3427
- ...output,
3428
- body: await parseErrorBody(output.body, context),
3429
- };
3430
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3431
- switch (errorCode) {
3432
- case "InternalException":
3433
- case "com.amazonaws.securityhub#InternalException":
3434
- throw await de_InternalExceptionRes(parsedOutput, context);
3435
- case "InvalidAccessException":
3436
- case "com.amazonaws.securityhub#InvalidAccessException":
3437
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3438
- case "InvalidInputException":
3439
- case "com.amazonaws.securityhub#InvalidInputException":
3440
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3441
- case "LimitExceededException":
3442
- case "com.amazonaws.securityhub#LimitExceededException":
3443
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3444
- case "ResourceNotFoundException":
3445
- case "com.amazonaws.securityhub#ResourceNotFoundException":
3446
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3447
- default:
3448
- const parsedBody = parsedOutput.body;
3449
- return throwDefaultError({
3450
- output,
3451
- parsedBody,
3452
- errorCode,
3453
- });
1754
+ export const de_GetMasterAccountCommand = async (output, context) => {
1755
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1756
+ return de_CommandError(output, context);
3454
1757
  }
1758
+ const contents = map({
1759
+ $metadata: deserializeMetadata(output),
1760
+ });
1761
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1762
+ const doc = take(data, {
1763
+ Master: (_) => de_Invitation(_, context),
1764
+ });
1765
+ Object.assign(contents, doc);
1766
+ return contents;
3455
1767
  };
3456
- export const de_InviteMembersCommand = async (output, context) => {
1768
+ export const de_GetMembersCommand = async (output, context) => {
3457
1769
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3458
- return de_InviteMembersCommandError(output, context);
1770
+ return de_CommandError(output, context);
3459
1771
  }
3460
1772
  const contents = map({
3461
1773
  $metadata: deserializeMetadata(output),
3462
1774
  });
3463
1775
  const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
3464
1776
  const doc = take(data, {
1777
+ Members: (_) => de_MemberList(_, context),
3465
1778
  UnprocessedAccounts: _json,
3466
1779
  });
3467
1780
  Object.assign(contents, doc);
3468
1781
  return contents;
3469
1782
  };
3470
- const de_InviteMembersCommandError = async (output, context) => {
3471
- const parsedOutput = {
3472
- ...output,
3473
- body: await parseErrorBody(output.body, context),
3474
- };
3475
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3476
- switch (errorCode) {
3477
- case "InternalException":
3478
- case "com.amazonaws.securityhub#InternalException":
3479
- throw await de_InternalExceptionRes(parsedOutput, context);
3480
- case "InvalidAccessException":
3481
- case "com.amazonaws.securityhub#InvalidAccessException":
3482
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3483
- case "InvalidInputException":
3484
- case "com.amazonaws.securityhub#InvalidInputException":
3485
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3486
- case "LimitExceededException":
3487
- case "com.amazonaws.securityhub#LimitExceededException":
3488
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3489
- case "ResourceNotFoundException":
3490
- case "com.amazonaws.securityhub#ResourceNotFoundException":
3491
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3492
- default:
3493
- const parsedBody = parsedOutput.body;
3494
- return throwDefaultError({
3495
- output,
3496
- parsedBody,
3497
- errorCode,
3498
- });
1783
+ export const de_GetSecurityControlDefinitionCommand = async (output, context) => {
1784
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1785
+ return de_CommandError(output, context);
1786
+ }
1787
+ const contents = map({
1788
+ $metadata: deserializeMetadata(output),
1789
+ });
1790
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1791
+ const doc = take(data, {
1792
+ SecurityControlDefinition: (_) => de_SecurityControlDefinition(_, context),
1793
+ });
1794
+ Object.assign(contents, doc);
1795
+ return contents;
1796
+ };
1797
+ export const de_InviteMembersCommand = async (output, context) => {
1798
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1799
+ return de_CommandError(output, context);
3499
1800
  }
1801
+ const contents = map({
1802
+ $metadata: deserializeMetadata(output),
1803
+ });
1804
+ const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
1805
+ const doc = take(data, {
1806
+ UnprocessedAccounts: _json,
1807
+ });
1808
+ Object.assign(contents, doc);
1809
+ return contents;
3500
1810
  };
3501
1811
  export const de_ListAutomationRulesCommand = async (output, context) => {
3502
1812
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3503
- return de_ListAutomationRulesCommandError(output, context);
1813
+ return de_CommandError(output, context);
3504
1814
  }
3505
1815
  const contents = map({
3506
1816
  $metadata: deserializeMetadata(output),
@@ -3513,40 +1823,9 @@ export const de_ListAutomationRulesCommand = async (output, context) => {
3513
1823
  Object.assign(contents, doc);
3514
1824
  return contents;
3515
1825
  };
3516
- const de_ListAutomationRulesCommandError = async (output, context) => {
3517
- const parsedOutput = {
3518
- ...output,
3519
- body: await parseErrorBody(output.body, context),
3520
- };
3521
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3522
- switch (errorCode) {
3523
- case "AccessDeniedException":
3524
- case "com.amazonaws.securityhub#AccessDeniedException":
3525
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3526
- case "InternalException":
3527
- case "com.amazonaws.securityhub#InternalException":
3528
- throw await de_InternalExceptionRes(parsedOutput, context);
3529
- case "InvalidAccessException":
3530
- case "com.amazonaws.securityhub#InvalidAccessException":
3531
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3532
- case "InvalidInputException":
3533
- case "com.amazonaws.securityhub#InvalidInputException":
3534
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3535
- case "LimitExceededException":
3536
- case "com.amazonaws.securityhub#LimitExceededException":
3537
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3538
- default:
3539
- const parsedBody = parsedOutput.body;
3540
- return throwDefaultError({
3541
- output,
3542
- parsedBody,
3543
- errorCode,
3544
- });
3545
- }
3546
- };
3547
1826
  export const de_ListConfigurationPoliciesCommand = async (output, context) => {
3548
1827
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3549
- return de_ListConfigurationPoliciesCommandError(output, context);
1828
+ return de_CommandError(output, context);
3550
1829
  }
3551
1830
  const contents = map({
3552
1831
  $metadata: deserializeMetadata(output),
@@ -3559,40 +1838,9 @@ export const de_ListConfigurationPoliciesCommand = async (output, context) => {
3559
1838
  Object.assign(contents, doc);
3560
1839
  return contents;
3561
1840
  };
3562
- const de_ListConfigurationPoliciesCommandError = async (output, context) => {
3563
- const parsedOutput = {
3564
- ...output,
3565
- body: await parseErrorBody(output.body, context),
3566
- };
3567
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3568
- switch (errorCode) {
3569
- case "AccessDeniedException":
3570
- case "com.amazonaws.securityhub#AccessDeniedException":
3571
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3572
- case "InternalException":
3573
- case "com.amazonaws.securityhub#InternalException":
3574
- throw await de_InternalExceptionRes(parsedOutput, context);
3575
- case "InvalidAccessException":
3576
- case "com.amazonaws.securityhub#InvalidAccessException":
3577
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3578
- case "InvalidInputException":
3579
- case "com.amazonaws.securityhub#InvalidInputException":
3580
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3581
- case "LimitExceededException":
3582
- case "com.amazonaws.securityhub#LimitExceededException":
3583
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3584
- default:
3585
- const parsedBody = parsedOutput.body;
3586
- return throwDefaultError({
3587
- output,
3588
- parsedBody,
3589
- errorCode,
3590
- });
3591
- }
3592
- };
3593
1841
  export const de_ListConfigurationPolicyAssociationsCommand = async (output, context) => {
3594
1842
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3595
- return de_ListConfigurationPolicyAssociationsCommandError(output, context);
1843
+ return de_CommandError(output, context);
3596
1844
  }
3597
1845
  const contents = map({
3598
1846
  $metadata: deserializeMetadata(output),
@@ -3605,40 +1853,9 @@ export const de_ListConfigurationPolicyAssociationsCommand = async (output, cont
3605
1853
  Object.assign(contents, doc);
3606
1854
  return contents;
3607
1855
  };
3608
- const de_ListConfigurationPolicyAssociationsCommandError = async (output, context) => {
3609
- const parsedOutput = {
3610
- ...output,
3611
- body: await parseErrorBody(output.body, context),
3612
- };
3613
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3614
- switch (errorCode) {
3615
- case "AccessDeniedException":
3616
- case "com.amazonaws.securityhub#AccessDeniedException":
3617
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3618
- case "InternalException":
3619
- case "com.amazonaws.securityhub#InternalException":
3620
- throw await de_InternalExceptionRes(parsedOutput, context);
3621
- case "InvalidAccessException":
3622
- case "com.amazonaws.securityhub#InvalidAccessException":
3623
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3624
- case "InvalidInputException":
3625
- case "com.amazonaws.securityhub#InvalidInputException":
3626
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3627
- case "LimitExceededException":
3628
- case "com.amazonaws.securityhub#LimitExceededException":
3629
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3630
- default:
3631
- const parsedBody = parsedOutput.body;
3632
- return throwDefaultError({
3633
- output,
3634
- parsedBody,
3635
- errorCode,
3636
- });
3637
- }
3638
- };
3639
1856
  export const de_ListEnabledProductsForImportCommand = async (output, context) => {
3640
1857
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3641
- return de_ListEnabledProductsForImportCommandError(output, context);
1858
+ return de_CommandError(output, context);
3642
1859
  }
3643
1860
  const contents = map({
3644
1861
  $metadata: deserializeMetadata(output),
@@ -3651,34 +1868,9 @@ export const de_ListEnabledProductsForImportCommand = async (output, context) =>
3651
1868
  Object.assign(contents, doc);
3652
1869
  return contents;
3653
1870
  };
3654
- const de_ListEnabledProductsForImportCommandError = async (output, context) => {
3655
- const parsedOutput = {
3656
- ...output,
3657
- body: await parseErrorBody(output.body, context),
3658
- };
3659
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3660
- switch (errorCode) {
3661
- case "InternalException":
3662
- case "com.amazonaws.securityhub#InternalException":
3663
- throw await de_InternalExceptionRes(parsedOutput, context);
3664
- case "InvalidAccessException":
3665
- case "com.amazonaws.securityhub#InvalidAccessException":
3666
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3667
- case "LimitExceededException":
3668
- case "com.amazonaws.securityhub#LimitExceededException":
3669
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3670
- default:
3671
- const parsedBody = parsedOutput.body;
3672
- return throwDefaultError({
3673
- output,
3674
- parsedBody,
3675
- errorCode,
3676
- });
3677
- }
3678
- };
3679
1871
  export const de_ListFindingAggregatorsCommand = async (output, context) => {
3680
1872
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3681
- return de_ListFindingAggregatorsCommandError(output, context);
1873
+ return de_CommandError(output, context);
3682
1874
  }
3683
1875
  const contents = map({
3684
1876
  $metadata: deserializeMetadata(output),
@@ -3691,40 +1883,9 @@ export const de_ListFindingAggregatorsCommand = async (output, context) => {
3691
1883
  Object.assign(contents, doc);
3692
1884
  return contents;
3693
1885
  };
3694
- const de_ListFindingAggregatorsCommandError = async (output, context) => {
3695
- const parsedOutput = {
3696
- ...output,
3697
- body: await parseErrorBody(output.body, context),
3698
- };
3699
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3700
- switch (errorCode) {
3701
- case "AccessDeniedException":
3702
- case "com.amazonaws.securityhub#AccessDeniedException":
3703
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
3704
- case "InternalException":
3705
- case "com.amazonaws.securityhub#InternalException":
3706
- throw await de_InternalExceptionRes(parsedOutput, context);
3707
- case "InvalidAccessException":
3708
- case "com.amazonaws.securityhub#InvalidAccessException":
3709
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3710
- case "InvalidInputException":
3711
- case "com.amazonaws.securityhub#InvalidInputException":
3712
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3713
- case "LimitExceededException":
3714
- case "com.amazonaws.securityhub#LimitExceededException":
3715
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3716
- default:
3717
- const parsedBody = parsedOutput.body;
3718
- return throwDefaultError({
3719
- output,
3720
- parsedBody,
3721
- errorCode,
3722
- });
3723
- }
3724
- };
3725
1886
  export const de_ListInvitationsCommand = async (output, context) => {
3726
1887
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3727
- return de_ListInvitationsCommandError(output, context);
1888
+ return de_CommandError(output, context);
3728
1889
  }
3729
1890
  const contents = map({
3730
1891
  $metadata: deserializeMetadata(output),
@@ -3737,37 +1898,9 @@ export const de_ListInvitationsCommand = async (output, context) => {
3737
1898
  Object.assign(contents, doc);
3738
1899
  return contents;
3739
1900
  };
3740
- const de_ListInvitationsCommandError = async (output, context) => {
3741
- const parsedOutput = {
3742
- ...output,
3743
- body: await parseErrorBody(output.body, context),
3744
- };
3745
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3746
- switch (errorCode) {
3747
- case "InternalException":
3748
- case "com.amazonaws.securityhub#InternalException":
3749
- throw await de_InternalExceptionRes(parsedOutput, context);
3750
- case "InvalidAccessException":
3751
- case "com.amazonaws.securityhub#InvalidAccessException":
3752
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3753
- case "InvalidInputException":
3754
- case "com.amazonaws.securityhub#InvalidInputException":
3755
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3756
- case "LimitExceededException":
3757
- case "com.amazonaws.securityhub#LimitExceededException":
3758
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3759
- default:
3760
- const parsedBody = parsedOutput.body;
3761
- return throwDefaultError({
3762
- output,
3763
- parsedBody,
3764
- errorCode,
3765
- });
3766
- }
3767
- };
3768
1901
  export const de_ListMembersCommand = async (output, context) => {
3769
1902
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3770
- return de_ListMembersCommandError(output, context);
1903
+ return de_CommandError(output, context);
3771
1904
  }
3772
1905
  const contents = map({
3773
1906
  $metadata: deserializeMetadata(output),
@@ -3776,41 +1909,13 @@ export const de_ListMembersCommand = async (output, context) => {
3776
1909
  const doc = take(data, {
3777
1910
  Members: (_) => de_MemberList(_, context),
3778
1911
  NextToken: __expectString,
3779
- });
3780
- Object.assign(contents, doc);
3781
- return contents;
3782
- };
3783
- const de_ListMembersCommandError = async (output, context) => {
3784
- const parsedOutput = {
3785
- ...output,
3786
- body: await parseErrorBody(output.body, context),
3787
- };
3788
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3789
- switch (errorCode) {
3790
- case "InternalException":
3791
- case "com.amazonaws.securityhub#InternalException":
3792
- throw await de_InternalExceptionRes(parsedOutput, context);
3793
- case "InvalidAccessException":
3794
- case "com.amazonaws.securityhub#InvalidAccessException":
3795
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3796
- case "InvalidInputException":
3797
- case "com.amazonaws.securityhub#InvalidInputException":
3798
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3799
- case "LimitExceededException":
3800
- case "com.amazonaws.securityhub#LimitExceededException":
3801
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3802
- default:
3803
- const parsedBody = parsedOutput.body;
3804
- return throwDefaultError({
3805
- output,
3806
- parsedBody,
3807
- errorCode,
3808
- });
3809
- }
1912
+ });
1913
+ Object.assign(contents, doc);
1914
+ return contents;
3810
1915
  };
3811
1916
  export const de_ListOrganizationAdminAccountsCommand = async (output, context) => {
3812
1917
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3813
- return de_ListOrganizationAdminAccountsCommandError(output, context);
1918
+ return de_CommandError(output, context);
3814
1919
  }
3815
1920
  const contents = map({
3816
1921
  $metadata: deserializeMetadata(output),
@@ -3823,37 +1928,9 @@ export const de_ListOrganizationAdminAccountsCommand = async (output, context) =
3823
1928
  Object.assign(contents, doc);
3824
1929
  return contents;
3825
1930
  };
3826
- const de_ListOrganizationAdminAccountsCommandError = async (output, context) => {
3827
- const parsedOutput = {
3828
- ...output,
3829
- body: await parseErrorBody(output.body, context),
3830
- };
3831
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3832
- switch (errorCode) {
3833
- case "InternalException":
3834
- case "com.amazonaws.securityhub#InternalException":
3835
- throw await de_InternalExceptionRes(parsedOutput, context);
3836
- case "InvalidAccessException":
3837
- case "com.amazonaws.securityhub#InvalidAccessException":
3838
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3839
- case "InvalidInputException":
3840
- case "com.amazonaws.securityhub#InvalidInputException":
3841
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3842
- case "LimitExceededException":
3843
- case "com.amazonaws.securityhub#LimitExceededException":
3844
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3845
- default:
3846
- const parsedBody = parsedOutput.body;
3847
- return throwDefaultError({
3848
- output,
3849
- parsedBody,
3850
- errorCode,
3851
- });
3852
- }
3853
- };
3854
1931
  export const de_ListSecurityControlDefinitionsCommand = async (output, context) => {
3855
1932
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3856
- return de_ListSecurityControlDefinitionsCommandError(output, context);
1933
+ return de_CommandError(output, context);
3857
1934
  }
3858
1935
  const contents = map({
3859
1936
  $metadata: deserializeMetadata(output),
@@ -3866,37 +1943,9 @@ export const de_ListSecurityControlDefinitionsCommand = async (output, context)
3866
1943
  Object.assign(contents, doc);
3867
1944
  return contents;
3868
1945
  };
3869
- const de_ListSecurityControlDefinitionsCommandError = async (output, context) => {
3870
- const parsedOutput = {
3871
- ...output,
3872
- body: await parseErrorBody(output.body, context),
3873
- };
3874
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3875
- switch (errorCode) {
3876
- case "InternalException":
3877
- case "com.amazonaws.securityhub#InternalException":
3878
- throw await de_InternalExceptionRes(parsedOutput, context);
3879
- case "InvalidAccessException":
3880
- case "com.amazonaws.securityhub#InvalidAccessException":
3881
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3882
- case "InvalidInputException":
3883
- case "com.amazonaws.securityhub#InvalidInputException":
3884
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3885
- case "LimitExceededException":
3886
- case "com.amazonaws.securityhub#LimitExceededException":
3887
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3888
- default:
3889
- const parsedBody = parsedOutput.body;
3890
- return throwDefaultError({
3891
- output,
3892
- parsedBody,
3893
- errorCode,
3894
- });
3895
- }
3896
- };
3897
1946
  export const de_ListStandardsControlAssociationsCommand = async (output, context) => {
3898
1947
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3899
- return de_ListStandardsControlAssociationsCommandError(output, context);
1948
+ return de_CommandError(output, context);
3900
1949
  }
3901
1950
  const contents = map({
3902
1951
  $metadata: deserializeMetadata(output),
@@ -3909,37 +1958,9 @@ export const de_ListStandardsControlAssociationsCommand = async (output, context
3909
1958
  Object.assign(contents, doc);
3910
1959
  return contents;
3911
1960
  };
3912
- const de_ListStandardsControlAssociationsCommandError = async (output, context) => {
3913
- const parsedOutput = {
3914
- ...output,
3915
- body: await parseErrorBody(output.body, context),
3916
- };
3917
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3918
- switch (errorCode) {
3919
- case "InternalException":
3920
- case "com.amazonaws.securityhub#InternalException":
3921
- throw await de_InternalExceptionRes(parsedOutput, context);
3922
- case "InvalidAccessException":
3923
- case "com.amazonaws.securityhub#InvalidAccessException":
3924
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
3925
- case "InvalidInputException":
3926
- case "com.amazonaws.securityhub#InvalidInputException":
3927
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3928
- case "LimitExceededException":
3929
- case "com.amazonaws.securityhub#LimitExceededException":
3930
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
3931
- default:
3932
- const parsedBody = parsedOutput.body;
3933
- return throwDefaultError({
3934
- output,
3935
- parsedBody,
3936
- errorCode,
3937
- });
3938
- }
3939
- };
3940
1961
  export const de_ListTagsForResourceCommand = async (output, context) => {
3941
1962
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3942
- return de_ListTagsForResourceCommandError(output, context);
1963
+ return de_CommandError(output, context);
3943
1964
  }
3944
1965
  const contents = map({
3945
1966
  $metadata: deserializeMetadata(output),
@@ -3951,34 +1972,9 @@ export const de_ListTagsForResourceCommand = async (output, context) => {
3951
1972
  Object.assign(contents, doc);
3952
1973
  return contents;
3953
1974
  };
3954
- const de_ListTagsForResourceCommandError = async (output, context) => {
3955
- const parsedOutput = {
3956
- ...output,
3957
- body: await parseErrorBody(output.body, context),
3958
- };
3959
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
3960
- switch (errorCode) {
3961
- case "InternalException":
3962
- case "com.amazonaws.securityhub#InternalException":
3963
- throw await de_InternalExceptionRes(parsedOutput, context);
3964
- case "InvalidInputException":
3965
- case "com.amazonaws.securityhub#InvalidInputException":
3966
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
3967
- case "ResourceNotFoundException":
3968
- case "com.amazonaws.securityhub#ResourceNotFoundException":
3969
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
3970
- default:
3971
- const parsedBody = parsedOutput.body;
3972
- return throwDefaultError({
3973
- output,
3974
- parsedBody,
3975
- errorCode,
3976
- });
3977
- }
3978
- };
3979
1975
  export const de_StartConfigurationPolicyAssociationCommand = async (output, context) => {
3980
1976
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3981
- return de_StartConfigurationPolicyAssociationCommandError(output, context);
1977
+ return de_CommandError(output, context);
3982
1978
  }
3983
1979
  const contents = map({
3984
1980
  $metadata: deserializeMetadata(output),
@@ -3996,43 +1992,9 @@ export const de_StartConfigurationPolicyAssociationCommand = async (output, cont
3996
1992
  Object.assign(contents, doc);
3997
1993
  return contents;
3998
1994
  };
3999
- const de_StartConfigurationPolicyAssociationCommandError = async (output, context) => {
4000
- const parsedOutput = {
4001
- ...output,
4002
- body: await parseErrorBody(output.body, context),
4003
- };
4004
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4005
- switch (errorCode) {
4006
- case "AccessDeniedException":
4007
- case "com.amazonaws.securityhub#AccessDeniedException":
4008
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4009
- case "InternalException":
4010
- case "com.amazonaws.securityhub#InternalException":
4011
- throw await de_InternalExceptionRes(parsedOutput, context);
4012
- case "InvalidAccessException":
4013
- case "com.amazonaws.securityhub#InvalidAccessException":
4014
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
4015
- case "InvalidInputException":
4016
- case "com.amazonaws.securityhub#InvalidInputException":
4017
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
4018
- case "LimitExceededException":
4019
- case "com.amazonaws.securityhub#LimitExceededException":
4020
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
4021
- case "ResourceNotFoundException":
4022
- case "com.amazonaws.securityhub#ResourceNotFoundException":
4023
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4024
- default:
4025
- const parsedBody = parsedOutput.body;
4026
- return throwDefaultError({
4027
- output,
4028
- parsedBody,
4029
- errorCode,
4030
- });
4031
- }
4032
- };
4033
1995
  export const de_StartConfigurationPolicyDisassociationCommand = async (output, context) => {
4034
1996
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4035
- return de_StartConfigurationPolicyDisassociationCommandError(output, context);
1997
+ return de_CommandError(output, context);
4036
1998
  }
4037
1999
  const contents = map({
4038
2000
  $metadata: deserializeMetadata(output),
@@ -4040,43 +2002,9 @@ export const de_StartConfigurationPolicyDisassociationCommand = async (output, c
4040
2002
  await collectBody(output.body, context);
4041
2003
  return contents;
4042
2004
  };
4043
- const de_StartConfigurationPolicyDisassociationCommandError = async (output, context) => {
4044
- const parsedOutput = {
4045
- ...output,
4046
- body: await parseErrorBody(output.body, context),
4047
- };
4048
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4049
- switch (errorCode) {
4050
- case "AccessDeniedException":
4051
- case "com.amazonaws.securityhub#AccessDeniedException":
4052
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4053
- case "InternalException":
4054
- case "com.amazonaws.securityhub#InternalException":
4055
- throw await de_InternalExceptionRes(parsedOutput, context);
4056
- case "InvalidAccessException":
4057
- case "com.amazonaws.securityhub#InvalidAccessException":
4058
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
4059
- case "InvalidInputException":
4060
- case "com.amazonaws.securityhub#InvalidInputException":
4061
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
4062
- case "LimitExceededException":
4063
- case "com.amazonaws.securityhub#LimitExceededException":
4064
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
4065
- case "ResourceNotFoundException":
4066
- case "com.amazonaws.securityhub#ResourceNotFoundException":
4067
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4068
- default:
4069
- const parsedBody = parsedOutput.body;
4070
- return throwDefaultError({
4071
- output,
4072
- parsedBody,
4073
- errorCode,
4074
- });
4075
- }
4076
- };
4077
2005
  export const de_TagResourceCommand = async (output, context) => {
4078
2006
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4079
- return de_TagResourceCommandError(output, context);
2007
+ return de_CommandError(output, context);
4080
2008
  }
4081
2009
  const contents = map({
4082
2010
  $metadata: deserializeMetadata(output),
@@ -4084,69 +2012,9 @@ export const de_TagResourceCommand = async (output, context) => {
4084
2012
  await collectBody(output.body, context);
4085
2013
  return contents;
4086
2014
  };
4087
- const de_TagResourceCommandError = async (output, context) => {
4088
- const parsedOutput = {
4089
- ...output,
4090
- body: await parseErrorBody(output.body, context),
4091
- };
4092
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4093
- switch (errorCode) {
4094
- case "InternalException":
4095
- case "com.amazonaws.securityhub#InternalException":
4096
- throw await de_InternalExceptionRes(parsedOutput, context);
4097
- case "InvalidInputException":
4098
- case "com.amazonaws.securityhub#InvalidInputException":
4099
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
4100
- case "ResourceNotFoundException":
4101
- case "com.amazonaws.securityhub#ResourceNotFoundException":
4102
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4103
- default:
4104
- const parsedBody = parsedOutput.body;
4105
- return throwDefaultError({
4106
- output,
4107
- parsedBody,
4108
- errorCode,
4109
- });
4110
- }
4111
- };
4112
2015
  export const de_UntagResourceCommand = async (output, context) => {
4113
2016
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4114
- return de_UntagResourceCommandError(output, context);
4115
- }
4116
- const contents = map({
4117
- $metadata: deserializeMetadata(output),
4118
- });
4119
- await collectBody(output.body, context);
4120
- return contents;
4121
- };
4122
- const de_UntagResourceCommandError = async (output, context) => {
4123
- const parsedOutput = {
4124
- ...output,
4125
- body: await parseErrorBody(output.body, context),
4126
- };
4127
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4128
- switch (errorCode) {
4129
- case "InternalException":
4130
- case "com.amazonaws.securityhub#InternalException":
4131
- throw await de_InternalExceptionRes(parsedOutput, context);
4132
- case "InvalidInputException":
4133
- case "com.amazonaws.securityhub#InvalidInputException":
4134
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
4135
- case "ResourceNotFoundException":
4136
- case "com.amazonaws.securityhub#ResourceNotFoundException":
4137
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4138
- default:
4139
- const parsedBody = parsedOutput.body;
4140
- return throwDefaultError({
4141
- output,
4142
- parsedBody,
4143
- errorCode,
4144
- });
4145
- }
4146
- };
4147
- export const de_UpdateActionTargetCommand = async (output, context) => {
4148
- if (output.statusCode !== 200 && output.statusCode >= 300) {
4149
- return de_UpdateActionTargetCommandError(output, context);
2017
+ return de_CommandError(output, context);
4150
2018
  }
4151
2019
  const contents = map({
4152
2020
  $metadata: deserializeMetadata(output),
@@ -4154,37 +2022,19 @@ export const de_UpdateActionTargetCommand = async (output, context) => {
4154
2022
  await collectBody(output.body, context);
4155
2023
  return contents;
4156
2024
  };
4157
- const de_UpdateActionTargetCommandError = async (output, context) => {
4158
- const parsedOutput = {
4159
- ...output,
4160
- body: await parseErrorBody(output.body, context),
4161
- };
4162
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4163
- switch (errorCode) {
4164
- case "InternalException":
4165
- case "com.amazonaws.securityhub#InternalException":
4166
- throw await de_InternalExceptionRes(parsedOutput, context);
4167
- case "InvalidAccessException":
4168
- case "com.amazonaws.securityhub#InvalidAccessException":
4169
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
4170
- case "InvalidInputException":
4171
- case "com.amazonaws.securityhub#InvalidInputException":
4172
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
4173
- case "ResourceNotFoundException":
4174
- case "com.amazonaws.securityhub#ResourceNotFoundException":
4175
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4176
- default:
4177
- const parsedBody = parsedOutput.body;
4178
- return throwDefaultError({
4179
- output,
4180
- parsedBody,
4181
- errorCode,
4182
- });
2025
+ export const de_UpdateActionTargetCommand = async (output, context) => {
2026
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
2027
+ return de_CommandError(output, context);
4183
2028
  }
2029
+ const contents = map({
2030
+ $metadata: deserializeMetadata(output),
2031
+ });
2032
+ await collectBody(output.body, context);
2033
+ return contents;
4184
2034
  };
4185
2035
  export const de_UpdateConfigurationPolicyCommand = async (output, context) => {
4186
2036
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4187
- return de_UpdateConfigurationPolicyCommandError(output, context);
2037
+ return de_CommandError(output, context);
4188
2038
  }
4189
2039
  const contents = map({
4190
2040
  $metadata: deserializeMetadata(output),
@@ -4202,46 +2052,9 @@ export const de_UpdateConfigurationPolicyCommand = async (output, context) => {
4202
2052
  Object.assign(contents, doc);
4203
2053
  return contents;
4204
2054
  };
4205
- const de_UpdateConfigurationPolicyCommandError = async (output, context) => {
4206
- const parsedOutput = {
4207
- ...output,
4208
- body: await parseErrorBody(output.body, context),
4209
- };
4210
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4211
- switch (errorCode) {
4212
- case "AccessDeniedException":
4213
- case "com.amazonaws.securityhub#AccessDeniedException":
4214
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4215
- case "InternalException":
4216
- case "com.amazonaws.securityhub#InternalException":
4217
- throw await de_InternalExceptionRes(parsedOutput, context);
4218
- case "InvalidAccessException":
4219
- case "com.amazonaws.securityhub#InvalidAccessException":
4220
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
4221
- case "InvalidInputException":
4222
- case "com.amazonaws.securityhub#InvalidInputException":
4223
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
4224
- case "LimitExceededException":
4225
- case "com.amazonaws.securityhub#LimitExceededException":
4226
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
4227
- case "ResourceConflictException":
4228
- case "com.amazonaws.securityhub#ResourceConflictException":
4229
- throw await de_ResourceConflictExceptionRes(parsedOutput, context);
4230
- case "ResourceNotFoundException":
4231
- case "com.amazonaws.securityhub#ResourceNotFoundException":
4232
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4233
- default:
4234
- const parsedBody = parsedOutput.body;
4235
- return throwDefaultError({
4236
- output,
4237
- parsedBody,
4238
- errorCode,
4239
- });
4240
- }
4241
- };
4242
2055
  export const de_UpdateFindingAggregatorCommand = async (output, context) => {
4243
2056
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4244
- return de_UpdateFindingAggregatorCommandError(output, context);
2057
+ return de_CommandError(output, context);
4245
2058
  }
4246
2059
  const contents = map({
4247
2060
  $metadata: deserializeMetadata(output),
@@ -4256,43 +2069,9 @@ export const de_UpdateFindingAggregatorCommand = async (output, context) => {
4256
2069
  Object.assign(contents, doc);
4257
2070
  return contents;
4258
2071
  };
4259
- const de_UpdateFindingAggregatorCommandError = async (output, context) => {
4260
- const parsedOutput = {
4261
- ...output,
4262
- body: await parseErrorBody(output.body, context),
4263
- };
4264
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4265
- switch (errorCode) {
4266
- case "AccessDeniedException":
4267
- case "com.amazonaws.securityhub#AccessDeniedException":
4268
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4269
- case "InternalException":
4270
- case "com.amazonaws.securityhub#InternalException":
4271
- throw await de_InternalExceptionRes(parsedOutput, context);
4272
- case "InvalidAccessException":
4273
- case "com.amazonaws.securityhub#InvalidAccessException":
4274
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
4275
- case "InvalidInputException":
4276
- case "com.amazonaws.securityhub#InvalidInputException":
4277
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
4278
- case "LimitExceededException":
4279
- case "com.amazonaws.securityhub#LimitExceededException":
4280
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
4281
- case "ResourceNotFoundException":
4282
- case "com.amazonaws.securityhub#ResourceNotFoundException":
4283
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4284
- default:
4285
- const parsedBody = parsedOutput.body;
4286
- return throwDefaultError({
4287
- output,
4288
- parsedBody,
4289
- errorCode,
4290
- });
4291
- }
4292
- };
4293
2072
  export const de_UpdateFindingsCommand = async (output, context) => {
4294
2073
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4295
- return de_UpdateFindingsCommandError(output, context);
2074
+ return de_CommandError(output, context);
4296
2075
  }
4297
2076
  const contents = map({
4298
2077
  $metadata: deserializeMetadata(output),
@@ -4300,40 +2079,9 @@ export const de_UpdateFindingsCommand = async (output, context) => {
4300
2079
  await collectBody(output.body, context);
4301
2080
  return contents;
4302
2081
  };
4303
- const de_UpdateFindingsCommandError = async (output, context) => {
4304
- const parsedOutput = {
4305
- ...output,
4306
- body: await parseErrorBody(output.body, context),
4307
- };
4308
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4309
- switch (errorCode) {
4310
- case "InternalException":
4311
- case "com.amazonaws.securityhub#InternalException":
4312
- throw await de_InternalExceptionRes(parsedOutput, context);
4313
- case "InvalidAccessException":
4314
- case "com.amazonaws.securityhub#InvalidAccessException":
4315
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
4316
- case "InvalidInputException":
4317
- case "com.amazonaws.securityhub#InvalidInputException":
4318
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
4319
- case "LimitExceededException":
4320
- case "com.amazonaws.securityhub#LimitExceededException":
4321
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
4322
- case "ResourceNotFoundException":
4323
- case "com.amazonaws.securityhub#ResourceNotFoundException":
4324
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4325
- default:
4326
- const parsedBody = parsedOutput.body;
4327
- return throwDefaultError({
4328
- output,
4329
- parsedBody,
4330
- errorCode,
4331
- });
4332
- }
4333
- };
4334
2082
  export const de_UpdateInsightCommand = async (output, context) => {
4335
2083
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4336
- return de_UpdateInsightCommandError(output, context);
2084
+ return de_CommandError(output, context);
4337
2085
  }
4338
2086
  const contents = map({
4339
2087
  $metadata: deserializeMetadata(output),
@@ -4341,40 +2089,9 @@ export const de_UpdateInsightCommand = async (output, context) => {
4341
2089
  await collectBody(output.body, context);
4342
2090
  return contents;
4343
2091
  };
4344
- const de_UpdateInsightCommandError = async (output, context) => {
4345
- const parsedOutput = {
4346
- ...output,
4347
- body: await parseErrorBody(output.body, context),
4348
- };
4349
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4350
- switch (errorCode) {
4351
- case "InternalException":
4352
- case "com.amazonaws.securityhub#InternalException":
4353
- throw await de_InternalExceptionRes(parsedOutput, context);
4354
- case "InvalidAccessException":
4355
- case "com.amazonaws.securityhub#InvalidAccessException":
4356
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
4357
- case "InvalidInputException":
4358
- case "com.amazonaws.securityhub#InvalidInputException":
4359
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
4360
- case "LimitExceededException":
4361
- case "com.amazonaws.securityhub#LimitExceededException":
4362
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
4363
- case "ResourceNotFoundException":
4364
- case "com.amazonaws.securityhub#ResourceNotFoundException":
4365
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4366
- default:
4367
- const parsedBody = parsedOutput.body;
4368
- return throwDefaultError({
4369
- output,
4370
- parsedBody,
4371
- errorCode,
4372
- });
4373
- }
4374
- };
4375
2092
  export const de_UpdateOrganizationConfigurationCommand = async (output, context) => {
4376
2093
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4377
- return de_UpdateOrganizationConfigurationCommandError(output, context);
2094
+ return de_CommandError(output, context);
4378
2095
  }
4379
2096
  const contents = map({
4380
2097
  $metadata: deserializeMetadata(output),
@@ -4382,46 +2099,9 @@ export const de_UpdateOrganizationConfigurationCommand = async (output, context)
4382
2099
  await collectBody(output.body, context);
4383
2100
  return contents;
4384
2101
  };
4385
- const de_UpdateOrganizationConfigurationCommandError = async (output, context) => {
4386
- const parsedOutput = {
4387
- ...output,
4388
- body: await parseErrorBody(output.body, context),
4389
- };
4390
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4391
- switch (errorCode) {
4392
- case "AccessDeniedException":
4393
- case "com.amazonaws.securityhub#AccessDeniedException":
4394
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4395
- case "InternalException":
4396
- case "com.amazonaws.securityhub#InternalException":
4397
- throw await de_InternalExceptionRes(parsedOutput, context);
4398
- case "InvalidAccessException":
4399
- case "com.amazonaws.securityhub#InvalidAccessException":
4400
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
4401
- case "InvalidInputException":
4402
- case "com.amazonaws.securityhub#InvalidInputException":
4403
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
4404
- case "LimitExceededException":
4405
- case "com.amazonaws.securityhub#LimitExceededException":
4406
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
4407
- case "ResourceConflictException":
4408
- case "com.amazonaws.securityhub#ResourceConflictException":
4409
- throw await de_ResourceConflictExceptionRes(parsedOutput, context);
4410
- case "ResourceNotFoundException":
4411
- case "com.amazonaws.securityhub#ResourceNotFoundException":
4412
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4413
- default:
4414
- const parsedBody = parsedOutput.body;
4415
- return throwDefaultError({
4416
- output,
4417
- parsedBody,
4418
- errorCode,
4419
- });
4420
- }
4421
- };
4422
2102
  export const de_UpdateSecurityControlCommand = async (output, context) => {
4423
2103
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4424
- return de_UpdateSecurityControlCommandError(output, context);
2104
+ return de_CommandError(output, context);
4425
2105
  }
4426
2106
  const contents = map({
4427
2107
  $metadata: deserializeMetadata(output),
@@ -4429,46 +2109,9 @@ export const de_UpdateSecurityControlCommand = async (output, context) => {
4429
2109
  await collectBody(output.body, context);
4430
2110
  return contents;
4431
2111
  };
4432
- const de_UpdateSecurityControlCommandError = async (output, context) => {
4433
- const parsedOutput = {
4434
- ...output,
4435
- body: await parseErrorBody(output.body, context),
4436
- };
4437
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4438
- switch (errorCode) {
4439
- case "AccessDeniedException":
4440
- case "com.amazonaws.securityhub#AccessDeniedException":
4441
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4442
- case "InternalException":
4443
- case "com.amazonaws.securityhub#InternalException":
4444
- throw await de_InternalExceptionRes(parsedOutput, context);
4445
- case "InvalidAccessException":
4446
- case "com.amazonaws.securityhub#InvalidAccessException":
4447
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
4448
- case "InvalidInputException":
4449
- case "com.amazonaws.securityhub#InvalidInputException":
4450
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
4451
- case "LimitExceededException":
4452
- case "com.amazonaws.securityhub#LimitExceededException":
4453
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
4454
- case "ResourceInUseException":
4455
- case "com.amazonaws.securityhub#ResourceInUseException":
4456
- throw await de_ResourceInUseExceptionRes(parsedOutput, context);
4457
- case "ResourceNotFoundException":
4458
- case "com.amazonaws.securityhub#ResourceNotFoundException":
4459
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4460
- default:
4461
- const parsedBody = parsedOutput.body;
4462
- return throwDefaultError({
4463
- output,
4464
- parsedBody,
4465
- errorCode,
4466
- });
4467
- }
4468
- };
4469
2112
  export const de_UpdateSecurityHubConfigurationCommand = async (output, context) => {
4470
2113
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4471
- return de_UpdateSecurityHubConfigurationCommandError(output, context);
2114
+ return de_CommandError(output, context);
4472
2115
  }
4473
2116
  const contents = map({
4474
2117
  $metadata: deserializeMetadata(output),
@@ -4476,43 +2119,9 @@ export const de_UpdateSecurityHubConfigurationCommand = async (output, context)
4476
2119
  await collectBody(output.body, context);
4477
2120
  return contents;
4478
2121
  };
4479
- const de_UpdateSecurityHubConfigurationCommandError = async (output, context) => {
4480
- const parsedOutput = {
4481
- ...output,
4482
- body: await parseErrorBody(output.body, context),
4483
- };
4484
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4485
- switch (errorCode) {
4486
- case "AccessDeniedException":
4487
- case "com.amazonaws.securityhub#AccessDeniedException":
4488
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4489
- case "InternalException":
4490
- case "com.amazonaws.securityhub#InternalException":
4491
- throw await de_InternalExceptionRes(parsedOutput, context);
4492
- case "InvalidAccessException":
4493
- case "com.amazonaws.securityhub#InvalidAccessException":
4494
- throw await de_InvalidAccessExceptionRes(parsedOutput, context);
4495
- case "InvalidInputException":
4496
- case "com.amazonaws.securityhub#InvalidInputException":
4497
- throw await de_InvalidInputExceptionRes(parsedOutput, context);
4498
- case "LimitExceededException":
4499
- case "com.amazonaws.securityhub#LimitExceededException":
4500
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
4501
- case "ResourceNotFoundException":
4502
- case "com.amazonaws.securityhub#ResourceNotFoundException":
4503
- throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
4504
- default:
4505
- const parsedBody = parsedOutput.body;
4506
- return throwDefaultError({
4507
- output,
4508
- parsedBody,
4509
- errorCode,
4510
- });
4511
- }
4512
- };
4513
2122
  export const de_UpdateStandardsControlCommand = async (output, context) => {
4514
2123
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4515
- return de_UpdateStandardsControlCommandError(output, context);
2124
+ return de_CommandError(output, context);
4516
2125
  }
4517
2126
  const contents = map({
4518
2127
  $metadata: deserializeMetadata(output),
@@ -4520,16 +2129,13 @@ export const de_UpdateStandardsControlCommand = async (output, context) => {
4520
2129
  await collectBody(output.body, context);
4521
2130
  return contents;
4522
2131
  };
4523
- const de_UpdateStandardsControlCommandError = async (output, context) => {
2132
+ const de_CommandError = async (output, context) => {
4524
2133
  const parsedOutput = {
4525
2134
  ...output,
4526
2135
  body: await parseErrorBody(output.body, context),
4527
2136
  };
4528
2137
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
4529
2138
  switch (errorCode) {
4530
- case "AccessDeniedException":
4531
- case "com.amazonaws.securityhub#AccessDeniedException":
4532
- throw await de_AccessDeniedExceptionRes(parsedOutput, context);
4533
2139
  case "InternalException":
4534
2140
  case "com.amazonaws.securityhub#InternalException":
4535
2141
  throw await de_InternalExceptionRes(parsedOutput, context);
@@ -4539,9 +2145,21 @@ const de_UpdateStandardsControlCommandError = async (output, context) => {
4539
2145
  case "InvalidInputException":
4540
2146
  case "com.amazonaws.securityhub#InvalidInputException":
4541
2147
  throw await de_InvalidInputExceptionRes(parsedOutput, context);
2148
+ case "LimitExceededException":
2149
+ case "com.amazonaws.securityhub#LimitExceededException":
2150
+ throw await de_LimitExceededExceptionRes(parsedOutput, context);
4542
2151
  case "ResourceNotFoundException":
4543
2152
  case "com.amazonaws.securityhub#ResourceNotFoundException":
4544
2153
  throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
2154
+ case "AccessDeniedException":
2155
+ case "com.amazonaws.securityhub#AccessDeniedException":
2156
+ throw await de_AccessDeniedExceptionRes(parsedOutput, context);
2157
+ case "ResourceConflictException":
2158
+ case "com.amazonaws.securityhub#ResourceConflictException":
2159
+ throw await de_ResourceConflictExceptionRes(parsedOutput, context);
2160
+ case "ResourceInUseException":
2161
+ case "com.amazonaws.securityhub#ResourceInUseException":
2162
+ throw await de_ResourceInUseExceptionRes(parsedOutput, context);
4545
2163
  default:
4546
2164
  const parsedBody = parsedOutput.body;
4547
2165
  return throwDefaultError({