@aws-sdk/client-pinpoint-email 3.504.0 → 3.507.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist-cjs/index.js CHANGED
@@ -1024,7 +1024,7 @@ var se_UpdateConfigurationSetEventDestinationCommand = /* @__PURE__ */ __name(as
1024
1024
  }, "se_UpdateConfigurationSetEventDestinationCommand");
1025
1025
  var de_CreateConfigurationSetCommand = /* @__PURE__ */ __name(async (output, context) => {
1026
1026
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1027
- return de_CreateConfigurationSetCommandError(output, context);
1027
+ return de_CommandError(output, context);
1028
1028
  }
1029
1029
  const contents = (0, import_smithy_client.map)({
1030
1030
  $metadata: deserializeMetadata(output)
@@ -1032,43 +1032,9 @@ var de_CreateConfigurationSetCommand = /* @__PURE__ */ __name(async (output, con
1032
1032
  await (0, import_smithy_client.collectBody)(output.body, context);
1033
1033
  return contents;
1034
1034
  }, "de_CreateConfigurationSetCommand");
1035
- var de_CreateConfigurationSetCommandError = /* @__PURE__ */ __name(async (output, context) => {
1036
- const parsedOutput = {
1037
- ...output,
1038
- body: await parseErrorBody(output.body, context)
1039
- };
1040
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1041
- switch (errorCode) {
1042
- case "AlreadyExistsException":
1043
- case "com.amazonaws.pinpointemail#AlreadyExistsException":
1044
- throw await de_AlreadyExistsExceptionRes(parsedOutput, context);
1045
- case "BadRequestException":
1046
- case "com.amazonaws.pinpointemail#BadRequestException":
1047
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1048
- case "ConcurrentModificationException":
1049
- case "com.amazonaws.pinpointemail#ConcurrentModificationException":
1050
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1051
- case "LimitExceededException":
1052
- case "com.amazonaws.pinpointemail#LimitExceededException":
1053
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1054
- case "NotFoundException":
1055
- case "com.amazonaws.pinpointemail#NotFoundException":
1056
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1057
- case "TooManyRequestsException":
1058
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1059
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1060
- default:
1061
- const parsedBody = parsedOutput.body;
1062
- return throwDefaultError({
1063
- output,
1064
- parsedBody,
1065
- errorCode
1066
- });
1067
- }
1068
- }, "de_CreateConfigurationSetCommandError");
1069
1035
  var de_CreateConfigurationSetEventDestinationCommand = /* @__PURE__ */ __name(async (output, context) => {
1070
1036
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1071
- return de_CreateConfigurationSetEventDestinationCommandError(output, context);
1037
+ return de_CommandError(output, context);
1072
1038
  }
1073
1039
  const contents = (0, import_smithy_client.map)({
1074
1040
  $metadata: deserializeMetadata(output)
@@ -1076,40 +1042,9 @@ var de_CreateConfigurationSetEventDestinationCommand = /* @__PURE__ */ __name(as
1076
1042
  await (0, import_smithy_client.collectBody)(output.body, context);
1077
1043
  return contents;
1078
1044
  }, "de_CreateConfigurationSetEventDestinationCommand");
1079
- var de_CreateConfigurationSetEventDestinationCommandError = /* @__PURE__ */ __name(async (output, context) => {
1080
- const parsedOutput = {
1081
- ...output,
1082
- body: await parseErrorBody(output.body, context)
1083
- };
1084
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1085
- switch (errorCode) {
1086
- case "AlreadyExistsException":
1087
- case "com.amazonaws.pinpointemail#AlreadyExistsException":
1088
- throw await de_AlreadyExistsExceptionRes(parsedOutput, context);
1089
- case "BadRequestException":
1090
- case "com.amazonaws.pinpointemail#BadRequestException":
1091
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1092
- case "LimitExceededException":
1093
- case "com.amazonaws.pinpointemail#LimitExceededException":
1094
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1095
- case "NotFoundException":
1096
- case "com.amazonaws.pinpointemail#NotFoundException":
1097
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1098
- case "TooManyRequestsException":
1099
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1100
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1101
- default:
1102
- const parsedBody = parsedOutput.body;
1103
- return throwDefaultError({
1104
- output,
1105
- parsedBody,
1106
- errorCode
1107
- });
1108
- }
1109
- }, "de_CreateConfigurationSetEventDestinationCommandError");
1110
1045
  var de_CreateDedicatedIpPoolCommand = /* @__PURE__ */ __name(async (output, context) => {
1111
1046
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1112
- return de_CreateDedicatedIpPoolCommandError(output, context);
1047
+ return de_CommandError(output, context);
1113
1048
  }
1114
1049
  const contents = (0, import_smithy_client.map)({
1115
1050
  $metadata: deserializeMetadata(output)
@@ -1117,40 +1052,9 @@ var de_CreateDedicatedIpPoolCommand = /* @__PURE__ */ __name(async (output, cont
1117
1052
  await (0, import_smithy_client.collectBody)(output.body, context);
1118
1053
  return contents;
1119
1054
  }, "de_CreateDedicatedIpPoolCommand");
1120
- var de_CreateDedicatedIpPoolCommandError = /* @__PURE__ */ __name(async (output, context) => {
1121
- const parsedOutput = {
1122
- ...output,
1123
- body: await parseErrorBody(output.body, context)
1124
- };
1125
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1126
- switch (errorCode) {
1127
- case "AlreadyExistsException":
1128
- case "com.amazonaws.pinpointemail#AlreadyExistsException":
1129
- throw await de_AlreadyExistsExceptionRes(parsedOutput, context);
1130
- case "BadRequestException":
1131
- case "com.amazonaws.pinpointemail#BadRequestException":
1132
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1133
- case "ConcurrentModificationException":
1134
- case "com.amazonaws.pinpointemail#ConcurrentModificationException":
1135
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1136
- case "LimitExceededException":
1137
- case "com.amazonaws.pinpointemail#LimitExceededException":
1138
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1139
- case "TooManyRequestsException":
1140
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1141
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1142
- default:
1143
- const parsedBody = parsedOutput.body;
1144
- return throwDefaultError({
1145
- output,
1146
- parsedBody,
1147
- errorCode
1148
- });
1149
- }
1150
- }, "de_CreateDedicatedIpPoolCommandError");
1151
1055
  var de_CreateDeliverabilityTestReportCommand = /* @__PURE__ */ __name(async (output, context) => {
1152
1056
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1153
- return de_CreateDeliverabilityTestReportCommandError(output, context);
1057
+ return de_CommandError(output, context);
1154
1058
  }
1155
1059
  const contents = (0, import_smithy_client.map)({
1156
1060
  $metadata: deserializeMetadata(output)
@@ -1163,52 +1067,9 @@ var de_CreateDeliverabilityTestReportCommand = /* @__PURE__ */ __name(async (out
1163
1067
  Object.assign(contents, doc);
1164
1068
  return contents;
1165
1069
  }, "de_CreateDeliverabilityTestReportCommand");
1166
- var de_CreateDeliverabilityTestReportCommandError = /* @__PURE__ */ __name(async (output, context) => {
1167
- const parsedOutput = {
1168
- ...output,
1169
- body: await parseErrorBody(output.body, context)
1170
- };
1171
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1172
- switch (errorCode) {
1173
- case "AccountSuspendedException":
1174
- case "com.amazonaws.pinpointemail#AccountSuspendedException":
1175
- throw await de_AccountSuspendedExceptionRes(parsedOutput, context);
1176
- case "BadRequestException":
1177
- case "com.amazonaws.pinpointemail#BadRequestException":
1178
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1179
- case "ConcurrentModificationException":
1180
- case "com.amazonaws.pinpointemail#ConcurrentModificationException":
1181
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1182
- case "LimitExceededException":
1183
- case "com.amazonaws.pinpointemail#LimitExceededException":
1184
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1185
- case "MailFromDomainNotVerifiedException":
1186
- case "com.amazonaws.pinpointemail#MailFromDomainNotVerifiedException":
1187
- throw await de_MailFromDomainNotVerifiedExceptionRes(parsedOutput, context);
1188
- case "MessageRejected":
1189
- case "com.amazonaws.pinpointemail#MessageRejected":
1190
- throw await de_MessageRejectedRes(parsedOutput, context);
1191
- case "NotFoundException":
1192
- case "com.amazonaws.pinpointemail#NotFoundException":
1193
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1194
- case "SendingPausedException":
1195
- case "com.amazonaws.pinpointemail#SendingPausedException":
1196
- throw await de_SendingPausedExceptionRes(parsedOutput, context);
1197
- case "TooManyRequestsException":
1198
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1199
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1200
- default:
1201
- const parsedBody = parsedOutput.body;
1202
- return throwDefaultError({
1203
- output,
1204
- parsedBody,
1205
- errorCode
1206
- });
1207
- }
1208
- }, "de_CreateDeliverabilityTestReportCommandError");
1209
1070
  var de_CreateEmailIdentityCommand = /* @__PURE__ */ __name(async (output, context) => {
1210
1071
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1211
- return de_CreateEmailIdentityCommandError(output, context);
1072
+ return de_CommandError(output, context);
1212
1073
  }
1213
1074
  const contents = (0, import_smithy_client.map)({
1214
1075
  $metadata: deserializeMetadata(output)
@@ -1222,37 +1083,9 @@ var de_CreateEmailIdentityCommand = /* @__PURE__ */ __name(async (output, contex
1222
1083
  Object.assign(contents, doc);
1223
1084
  return contents;
1224
1085
  }, "de_CreateEmailIdentityCommand");
1225
- var de_CreateEmailIdentityCommandError = /* @__PURE__ */ __name(async (output, context) => {
1226
- const parsedOutput = {
1227
- ...output,
1228
- body: await parseErrorBody(output.body, context)
1229
- };
1230
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1231
- switch (errorCode) {
1232
- case "BadRequestException":
1233
- case "com.amazonaws.pinpointemail#BadRequestException":
1234
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1235
- case "ConcurrentModificationException":
1236
- case "com.amazonaws.pinpointemail#ConcurrentModificationException":
1237
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1238
- case "LimitExceededException":
1239
- case "com.amazonaws.pinpointemail#LimitExceededException":
1240
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1241
- case "TooManyRequestsException":
1242
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1243
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1244
- default:
1245
- const parsedBody = parsedOutput.body;
1246
- return throwDefaultError({
1247
- output,
1248
- parsedBody,
1249
- errorCode
1250
- });
1251
- }
1252
- }, "de_CreateEmailIdentityCommandError");
1253
1086
  var de_DeleteConfigurationSetCommand = /* @__PURE__ */ __name(async (output, context) => {
1254
1087
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1255
- return de_DeleteConfigurationSetCommandError(output, context);
1088
+ return de_CommandError(output, context);
1256
1089
  }
1257
1090
  const contents = (0, import_smithy_client.map)({
1258
1091
  $metadata: deserializeMetadata(output)
@@ -1260,37 +1093,9 @@ var de_DeleteConfigurationSetCommand = /* @__PURE__ */ __name(async (output, con
1260
1093
  await (0, import_smithy_client.collectBody)(output.body, context);
1261
1094
  return contents;
1262
1095
  }, "de_DeleteConfigurationSetCommand");
1263
- var de_DeleteConfigurationSetCommandError = /* @__PURE__ */ __name(async (output, context) => {
1264
- const parsedOutput = {
1265
- ...output,
1266
- body: await parseErrorBody(output.body, context)
1267
- };
1268
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1269
- switch (errorCode) {
1270
- case "BadRequestException":
1271
- case "com.amazonaws.pinpointemail#BadRequestException":
1272
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1273
- case "ConcurrentModificationException":
1274
- case "com.amazonaws.pinpointemail#ConcurrentModificationException":
1275
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1276
- case "NotFoundException":
1277
- case "com.amazonaws.pinpointemail#NotFoundException":
1278
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1279
- case "TooManyRequestsException":
1280
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1281
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1282
- default:
1283
- const parsedBody = parsedOutput.body;
1284
- return throwDefaultError({
1285
- output,
1286
- parsedBody,
1287
- errorCode
1288
- });
1289
- }
1290
- }, "de_DeleteConfigurationSetCommandError");
1291
1096
  var de_DeleteConfigurationSetEventDestinationCommand = /* @__PURE__ */ __name(async (output, context) => {
1292
1097
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1293
- return de_DeleteConfigurationSetEventDestinationCommandError(output, context);
1098
+ return de_CommandError(output, context);
1294
1099
  }
1295
1100
  const contents = (0, import_smithy_client.map)({
1296
1101
  $metadata: deserializeMetadata(output)
@@ -1298,34 +1103,9 @@ var de_DeleteConfigurationSetEventDestinationCommand = /* @__PURE__ */ __name(as
1298
1103
  await (0, import_smithy_client.collectBody)(output.body, context);
1299
1104
  return contents;
1300
1105
  }, "de_DeleteConfigurationSetEventDestinationCommand");
1301
- var de_DeleteConfigurationSetEventDestinationCommandError = /* @__PURE__ */ __name(async (output, context) => {
1302
- const parsedOutput = {
1303
- ...output,
1304
- body: await parseErrorBody(output.body, context)
1305
- };
1306
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1307
- switch (errorCode) {
1308
- case "BadRequestException":
1309
- case "com.amazonaws.pinpointemail#BadRequestException":
1310
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1311
- case "NotFoundException":
1312
- case "com.amazonaws.pinpointemail#NotFoundException":
1313
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1314
- case "TooManyRequestsException":
1315
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1316
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1317
- default:
1318
- const parsedBody = parsedOutput.body;
1319
- return throwDefaultError({
1320
- output,
1321
- parsedBody,
1322
- errorCode
1323
- });
1324
- }
1325
- }, "de_DeleteConfigurationSetEventDestinationCommandError");
1326
1106
  var de_DeleteDedicatedIpPoolCommand = /* @__PURE__ */ __name(async (output, context) => {
1327
1107
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1328
- return de_DeleteDedicatedIpPoolCommandError(output, context);
1108
+ return de_CommandError(output, context);
1329
1109
  }
1330
1110
  const contents = (0, import_smithy_client.map)({
1331
1111
  $metadata: deserializeMetadata(output)
@@ -1333,37 +1113,9 @@ var de_DeleteDedicatedIpPoolCommand = /* @__PURE__ */ __name(async (output, cont
1333
1113
  await (0, import_smithy_client.collectBody)(output.body, context);
1334
1114
  return contents;
1335
1115
  }, "de_DeleteDedicatedIpPoolCommand");
1336
- var de_DeleteDedicatedIpPoolCommandError = /* @__PURE__ */ __name(async (output, context) => {
1337
- const parsedOutput = {
1338
- ...output,
1339
- body: await parseErrorBody(output.body, context)
1340
- };
1341
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1342
- switch (errorCode) {
1343
- case "BadRequestException":
1344
- case "com.amazonaws.pinpointemail#BadRequestException":
1345
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1346
- case "ConcurrentModificationException":
1347
- case "com.amazonaws.pinpointemail#ConcurrentModificationException":
1348
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1349
- case "NotFoundException":
1350
- case "com.amazonaws.pinpointemail#NotFoundException":
1351
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1352
- case "TooManyRequestsException":
1353
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1354
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1355
- default:
1356
- const parsedBody = parsedOutput.body;
1357
- return throwDefaultError({
1358
- output,
1359
- parsedBody,
1360
- errorCode
1361
- });
1362
- }
1363
- }, "de_DeleteDedicatedIpPoolCommandError");
1364
1116
  var de_DeleteEmailIdentityCommand = /* @__PURE__ */ __name(async (output, context) => {
1365
1117
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1366
- return de_DeleteEmailIdentityCommandError(output, context);
1118
+ return de_CommandError(output, context);
1367
1119
  }
1368
1120
  const contents = (0, import_smithy_client.map)({
1369
1121
  $metadata: deserializeMetadata(output)
@@ -1371,37 +1123,9 @@ var de_DeleteEmailIdentityCommand = /* @__PURE__ */ __name(async (output, contex
1371
1123
  await (0, import_smithy_client.collectBody)(output.body, context);
1372
1124
  return contents;
1373
1125
  }, "de_DeleteEmailIdentityCommand");
1374
- var de_DeleteEmailIdentityCommandError = /* @__PURE__ */ __name(async (output, context) => {
1375
- const parsedOutput = {
1376
- ...output,
1377
- body: await parseErrorBody(output.body, context)
1378
- };
1379
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1380
- switch (errorCode) {
1381
- case "BadRequestException":
1382
- case "com.amazonaws.pinpointemail#BadRequestException":
1383
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1384
- case "ConcurrentModificationException":
1385
- case "com.amazonaws.pinpointemail#ConcurrentModificationException":
1386
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1387
- case "NotFoundException":
1388
- case "com.amazonaws.pinpointemail#NotFoundException":
1389
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1390
- case "TooManyRequestsException":
1391
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1392
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1393
- default:
1394
- const parsedBody = parsedOutput.body;
1395
- return throwDefaultError({
1396
- output,
1397
- parsedBody,
1398
- errorCode
1399
- });
1400
- }
1401
- }, "de_DeleteEmailIdentityCommandError");
1402
1126
  var de_GetAccountCommand = /* @__PURE__ */ __name(async (output, context) => {
1403
1127
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1404
- return de_GetAccountCommandError(output, context);
1128
+ return de_CommandError(output, context);
1405
1129
  }
1406
1130
  const contents = (0, import_smithy_client.map)({
1407
1131
  $metadata: deserializeMetadata(output)
@@ -1414,73 +1138,26 @@ var de_GetAccountCommand = /* @__PURE__ */ __name(async (output, context) => {
1414
1138
  SendQuota: (_) => de_SendQuota(_, context),
1415
1139
  SendingEnabled: import_smithy_client.expectBoolean
1416
1140
  });
1417
- Object.assign(contents, doc);
1418
- return contents;
1419
- }, "de_GetAccountCommand");
1420
- var de_GetAccountCommandError = /* @__PURE__ */ __name(async (output, context) => {
1421
- const parsedOutput = {
1422
- ...output,
1423
- body: await parseErrorBody(output.body, context)
1424
- };
1425
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1426
- switch (errorCode) {
1427
- case "BadRequestException":
1428
- case "com.amazonaws.pinpointemail#BadRequestException":
1429
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1430
- case "TooManyRequestsException":
1431
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1432
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1433
- default:
1434
- const parsedBody = parsedOutput.body;
1435
- return throwDefaultError({
1436
- output,
1437
- parsedBody,
1438
- errorCode
1439
- });
1440
- }
1441
- }, "de_GetAccountCommandError");
1442
- var de_GetBlacklistReportsCommand = /* @__PURE__ */ __name(async (output, context) => {
1443
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1444
- return de_GetBlacklistReportsCommandError(output, context);
1445
- }
1446
- const contents = (0, import_smithy_client.map)({
1447
- $metadata: deserializeMetadata(output)
1448
- });
1449
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
1450
- const doc = (0, import_smithy_client.take)(data, {
1451
- BlacklistReport: (_) => de_BlacklistReport(_, context)
1452
- });
1453
- Object.assign(contents, doc);
1454
- return contents;
1455
- }, "de_GetBlacklistReportsCommand");
1456
- var de_GetBlacklistReportsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1457
- const parsedOutput = {
1458
- ...output,
1459
- body: await parseErrorBody(output.body, context)
1460
- };
1461
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1462
- switch (errorCode) {
1463
- case "BadRequestException":
1464
- case "com.amazonaws.pinpointemail#BadRequestException":
1465
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1466
- case "NotFoundException":
1467
- case "com.amazonaws.pinpointemail#NotFoundException":
1468
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1469
- case "TooManyRequestsException":
1470
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1471
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1472
- default:
1473
- const parsedBody = parsedOutput.body;
1474
- return throwDefaultError({
1475
- output,
1476
- parsedBody,
1477
- errorCode
1478
- });
1141
+ Object.assign(contents, doc);
1142
+ return contents;
1143
+ }, "de_GetAccountCommand");
1144
+ var de_GetBlacklistReportsCommand = /* @__PURE__ */ __name(async (output, context) => {
1145
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1146
+ return de_CommandError(output, context);
1479
1147
  }
1480
- }, "de_GetBlacklistReportsCommandError");
1148
+ const contents = (0, import_smithy_client.map)({
1149
+ $metadata: deserializeMetadata(output)
1150
+ });
1151
+ const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
1152
+ const doc = (0, import_smithy_client.take)(data, {
1153
+ BlacklistReport: (_) => de_BlacklistReport(_, context)
1154
+ });
1155
+ Object.assign(contents, doc);
1156
+ return contents;
1157
+ }, "de_GetBlacklistReportsCommand");
1481
1158
  var de_GetConfigurationSetCommand = /* @__PURE__ */ __name(async (output, context) => {
1482
1159
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1483
- return de_GetConfigurationSetCommandError(output, context);
1160
+ return de_CommandError(output, context);
1484
1161
  }
1485
1162
  const contents = (0, import_smithy_client.map)({
1486
1163
  $metadata: deserializeMetadata(output)
@@ -1497,34 +1174,9 @@ var de_GetConfigurationSetCommand = /* @__PURE__ */ __name(async (output, contex
1497
1174
  Object.assign(contents, doc);
1498
1175
  return contents;
1499
1176
  }, "de_GetConfigurationSetCommand");
1500
- var de_GetConfigurationSetCommandError = /* @__PURE__ */ __name(async (output, context) => {
1501
- const parsedOutput = {
1502
- ...output,
1503
- body: await parseErrorBody(output.body, context)
1504
- };
1505
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1506
- switch (errorCode) {
1507
- case "BadRequestException":
1508
- case "com.amazonaws.pinpointemail#BadRequestException":
1509
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1510
- case "NotFoundException":
1511
- case "com.amazonaws.pinpointemail#NotFoundException":
1512
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1513
- case "TooManyRequestsException":
1514
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1515
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1516
- default:
1517
- const parsedBody = parsedOutput.body;
1518
- return throwDefaultError({
1519
- output,
1520
- parsedBody,
1521
- errorCode
1522
- });
1523
- }
1524
- }, "de_GetConfigurationSetCommandError");
1525
1177
  var de_GetConfigurationSetEventDestinationsCommand = /* @__PURE__ */ __name(async (output, context) => {
1526
1178
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1527
- return de_GetConfigurationSetEventDestinationsCommandError(output, context);
1179
+ return de_CommandError(output, context);
1528
1180
  }
1529
1181
  const contents = (0, import_smithy_client.map)({
1530
1182
  $metadata: deserializeMetadata(output)
@@ -1536,34 +1188,9 @@ var de_GetConfigurationSetEventDestinationsCommand = /* @__PURE__ */ __name(asyn
1536
1188
  Object.assign(contents, doc);
1537
1189
  return contents;
1538
1190
  }, "de_GetConfigurationSetEventDestinationsCommand");
1539
- var de_GetConfigurationSetEventDestinationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1540
- const parsedOutput = {
1541
- ...output,
1542
- body: await parseErrorBody(output.body, context)
1543
- };
1544
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1545
- switch (errorCode) {
1546
- case "BadRequestException":
1547
- case "com.amazonaws.pinpointemail#BadRequestException":
1548
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1549
- case "NotFoundException":
1550
- case "com.amazonaws.pinpointemail#NotFoundException":
1551
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1552
- case "TooManyRequestsException":
1553
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1554
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1555
- default:
1556
- const parsedBody = parsedOutput.body;
1557
- return throwDefaultError({
1558
- output,
1559
- parsedBody,
1560
- errorCode
1561
- });
1562
- }
1563
- }, "de_GetConfigurationSetEventDestinationsCommandError");
1564
1191
  var de_GetDedicatedIpCommand = /* @__PURE__ */ __name(async (output, context) => {
1565
1192
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1566
- return de_GetDedicatedIpCommandError(output, context);
1193
+ return de_CommandError(output, context);
1567
1194
  }
1568
1195
  const contents = (0, import_smithy_client.map)({
1569
1196
  $metadata: deserializeMetadata(output)
@@ -1575,34 +1202,9 @@ var de_GetDedicatedIpCommand = /* @__PURE__ */ __name(async (output, context) =>
1575
1202
  Object.assign(contents, doc);
1576
1203
  return contents;
1577
1204
  }, "de_GetDedicatedIpCommand");
1578
- var de_GetDedicatedIpCommandError = /* @__PURE__ */ __name(async (output, context) => {
1579
- const parsedOutput = {
1580
- ...output,
1581
- body: await parseErrorBody(output.body, context)
1582
- };
1583
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1584
- switch (errorCode) {
1585
- case "BadRequestException":
1586
- case "com.amazonaws.pinpointemail#BadRequestException":
1587
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1588
- case "NotFoundException":
1589
- case "com.amazonaws.pinpointemail#NotFoundException":
1590
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1591
- case "TooManyRequestsException":
1592
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1593
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1594
- default:
1595
- const parsedBody = parsedOutput.body;
1596
- return throwDefaultError({
1597
- output,
1598
- parsedBody,
1599
- errorCode
1600
- });
1601
- }
1602
- }, "de_GetDedicatedIpCommandError");
1603
1205
  var de_GetDedicatedIpsCommand = /* @__PURE__ */ __name(async (output, context) => {
1604
1206
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1605
- return de_GetDedicatedIpsCommandError(output, context);
1207
+ return de_CommandError(output, context);
1606
1208
  }
1607
1209
  const contents = (0, import_smithy_client.map)({
1608
1210
  $metadata: deserializeMetadata(output)
@@ -1615,34 +1217,9 @@ var de_GetDedicatedIpsCommand = /* @__PURE__ */ __name(async (output, context) =
1615
1217
  Object.assign(contents, doc);
1616
1218
  return contents;
1617
1219
  }, "de_GetDedicatedIpsCommand");
1618
- var de_GetDedicatedIpsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1619
- const parsedOutput = {
1620
- ...output,
1621
- body: await parseErrorBody(output.body, context)
1622
- };
1623
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1624
- switch (errorCode) {
1625
- case "BadRequestException":
1626
- case "com.amazonaws.pinpointemail#BadRequestException":
1627
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1628
- case "NotFoundException":
1629
- case "com.amazonaws.pinpointemail#NotFoundException":
1630
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1631
- case "TooManyRequestsException":
1632
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1633
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1634
- default:
1635
- const parsedBody = parsedOutput.body;
1636
- return throwDefaultError({
1637
- output,
1638
- parsedBody,
1639
- errorCode
1640
- });
1641
- }
1642
- }, "de_GetDedicatedIpsCommandError");
1643
1220
  var de_GetDeliverabilityDashboardOptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
1644
1221
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1645
- return de_GetDeliverabilityDashboardOptionsCommandError(output, context);
1222
+ return de_CommandError(output, context);
1646
1223
  }
1647
1224
  const contents = (0, import_smithy_client.map)({
1648
1225
  $metadata: deserializeMetadata(output)
@@ -1658,34 +1235,9 @@ var de_GetDeliverabilityDashboardOptionsCommand = /* @__PURE__ */ __name(async (
1658
1235
  Object.assign(contents, doc);
1659
1236
  return contents;
1660
1237
  }, "de_GetDeliverabilityDashboardOptionsCommand");
1661
- var de_GetDeliverabilityDashboardOptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1662
- const parsedOutput = {
1663
- ...output,
1664
- body: await parseErrorBody(output.body, context)
1665
- };
1666
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1667
- switch (errorCode) {
1668
- case "BadRequestException":
1669
- case "com.amazonaws.pinpointemail#BadRequestException":
1670
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1671
- case "LimitExceededException":
1672
- case "com.amazonaws.pinpointemail#LimitExceededException":
1673
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
1674
- case "TooManyRequestsException":
1675
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1676
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1677
- default:
1678
- const parsedBody = parsedOutput.body;
1679
- return throwDefaultError({
1680
- output,
1681
- parsedBody,
1682
- errorCode
1683
- });
1684
- }
1685
- }, "de_GetDeliverabilityDashboardOptionsCommandError");
1686
1238
  var de_GetDeliverabilityTestReportCommand = /* @__PURE__ */ __name(async (output, context) => {
1687
1239
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1688
- return de_GetDeliverabilityTestReportCommandError(output, context);
1240
+ return de_CommandError(output, context);
1689
1241
  }
1690
1242
  const contents = (0, import_smithy_client.map)({
1691
1243
  $metadata: deserializeMetadata(output)
@@ -1701,34 +1253,9 @@ var de_GetDeliverabilityTestReportCommand = /* @__PURE__ */ __name(async (output
1701
1253
  Object.assign(contents, doc);
1702
1254
  return contents;
1703
1255
  }, "de_GetDeliverabilityTestReportCommand");
1704
- var de_GetDeliverabilityTestReportCommandError = /* @__PURE__ */ __name(async (output, context) => {
1705
- const parsedOutput = {
1706
- ...output,
1707
- body: await parseErrorBody(output.body, context)
1708
- };
1709
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1710
- switch (errorCode) {
1711
- case "BadRequestException":
1712
- case "com.amazonaws.pinpointemail#BadRequestException":
1713
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1714
- case "NotFoundException":
1715
- case "com.amazonaws.pinpointemail#NotFoundException":
1716
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1717
- case "TooManyRequestsException":
1718
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1719
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1720
- default:
1721
- const parsedBody = parsedOutput.body;
1722
- return throwDefaultError({
1723
- output,
1724
- parsedBody,
1725
- errorCode
1726
- });
1727
- }
1728
- }, "de_GetDeliverabilityTestReportCommandError");
1729
1256
  var de_GetDomainDeliverabilityCampaignCommand = /* @__PURE__ */ __name(async (output, context) => {
1730
1257
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1731
- return de_GetDomainDeliverabilityCampaignCommandError(output, context);
1258
+ return de_CommandError(output, context);
1732
1259
  }
1733
1260
  const contents = (0, import_smithy_client.map)({
1734
1261
  $metadata: deserializeMetadata(output)
@@ -1740,34 +1267,9 @@ var de_GetDomainDeliverabilityCampaignCommand = /* @__PURE__ */ __name(async (ou
1740
1267
  Object.assign(contents, doc);
1741
1268
  return contents;
1742
1269
  }, "de_GetDomainDeliverabilityCampaignCommand");
1743
- var de_GetDomainDeliverabilityCampaignCommandError = /* @__PURE__ */ __name(async (output, context) => {
1744
- const parsedOutput = {
1745
- ...output,
1746
- body: await parseErrorBody(output.body, context)
1747
- };
1748
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1749
- switch (errorCode) {
1750
- case "BadRequestException":
1751
- case "com.amazonaws.pinpointemail#BadRequestException":
1752
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1753
- case "NotFoundException":
1754
- case "com.amazonaws.pinpointemail#NotFoundException":
1755
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1756
- case "TooManyRequestsException":
1757
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1758
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1759
- default:
1760
- const parsedBody = parsedOutput.body;
1761
- return throwDefaultError({
1762
- output,
1763
- parsedBody,
1764
- errorCode
1765
- });
1766
- }
1767
- }, "de_GetDomainDeliverabilityCampaignCommandError");
1768
1270
  var de_GetDomainStatisticsReportCommand = /* @__PURE__ */ __name(async (output, context) => {
1769
1271
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1770
- return de_GetDomainStatisticsReportCommandError(output, context);
1272
+ return de_CommandError(output, context);
1771
1273
  }
1772
1274
  const contents = (0, import_smithy_client.map)({
1773
1275
  $metadata: deserializeMetadata(output)
@@ -1780,34 +1282,9 @@ var de_GetDomainStatisticsReportCommand = /* @__PURE__ */ __name(async (output,
1780
1282
  Object.assign(contents, doc);
1781
1283
  return contents;
1782
1284
  }, "de_GetDomainStatisticsReportCommand");
1783
- var de_GetDomainStatisticsReportCommandError = /* @__PURE__ */ __name(async (output, context) => {
1784
- const parsedOutput = {
1785
- ...output,
1786
- body: await parseErrorBody(output.body, context)
1787
- };
1788
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1789
- switch (errorCode) {
1790
- case "BadRequestException":
1791
- case "com.amazonaws.pinpointemail#BadRequestException":
1792
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1793
- case "NotFoundException":
1794
- case "com.amazonaws.pinpointemail#NotFoundException":
1795
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1796
- case "TooManyRequestsException":
1797
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1798
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1799
- default:
1800
- const parsedBody = parsedOutput.body;
1801
- return throwDefaultError({
1802
- output,
1803
- parsedBody,
1804
- errorCode
1805
- });
1806
- }
1807
- }, "de_GetDomainStatisticsReportCommandError");
1808
1285
  var de_GetEmailIdentityCommand = /* @__PURE__ */ __name(async (output, context) => {
1809
1286
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1810
- return de_GetEmailIdentityCommandError(output, context);
1287
+ return de_CommandError(output, context);
1811
1288
  }
1812
1289
  const contents = (0, import_smithy_client.map)({
1813
1290
  $metadata: deserializeMetadata(output)
@@ -1823,72 +1300,25 @@ var de_GetEmailIdentityCommand = /* @__PURE__ */ __name(async (output, context)
1823
1300
  });
1824
1301
  Object.assign(contents, doc);
1825
1302
  return contents;
1826
- }, "de_GetEmailIdentityCommand");
1827
- var de_GetEmailIdentityCommandError = /* @__PURE__ */ __name(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 "BadRequestException":
1835
- case "com.amazonaws.pinpointemail#BadRequestException":
1836
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1837
- case "NotFoundException":
1838
- case "com.amazonaws.pinpointemail#NotFoundException":
1839
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1840
- case "TooManyRequestsException":
1841
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1842
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1843
- default:
1844
- const parsedBody = parsedOutput.body;
1845
- return throwDefaultError({
1846
- output,
1847
- parsedBody,
1848
- errorCode
1849
- });
1850
- }
1851
- }, "de_GetEmailIdentityCommandError");
1852
- var de_ListConfigurationSetsCommand = /* @__PURE__ */ __name(async (output, context) => {
1853
- if (output.statusCode !== 200 && output.statusCode >= 300) {
1854
- return de_ListConfigurationSetsCommandError(output, context);
1855
- }
1856
- const contents = (0, import_smithy_client.map)({
1857
- $metadata: deserializeMetadata(output)
1858
- });
1859
- const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
1860
- const doc = (0, import_smithy_client.take)(data, {
1861
- ConfigurationSets: import_smithy_client._json,
1862
- NextToken: import_smithy_client.expectString
1863
- });
1864
- Object.assign(contents, doc);
1865
- return contents;
1866
- }, "de_ListConfigurationSetsCommand");
1867
- var de_ListConfigurationSetsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1868
- const parsedOutput = {
1869
- ...output,
1870
- body: await parseErrorBody(output.body, context)
1871
- };
1872
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1873
- switch (errorCode) {
1874
- case "BadRequestException":
1875
- case "com.amazonaws.pinpointemail#BadRequestException":
1876
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1877
- case "TooManyRequestsException":
1878
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1879
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1880
- default:
1881
- const parsedBody = parsedOutput.body;
1882
- return throwDefaultError({
1883
- output,
1884
- parsedBody,
1885
- errorCode
1886
- });
1303
+ }, "de_GetEmailIdentityCommand");
1304
+ var de_ListConfigurationSetsCommand = /* @__PURE__ */ __name(async (output, context) => {
1305
+ if (output.statusCode !== 200 && output.statusCode >= 300) {
1306
+ return de_CommandError(output, context);
1887
1307
  }
1888
- }, "de_ListConfigurationSetsCommandError");
1308
+ const contents = (0, import_smithy_client.map)({
1309
+ $metadata: deserializeMetadata(output)
1310
+ });
1311
+ const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
1312
+ const doc = (0, import_smithy_client.take)(data, {
1313
+ ConfigurationSets: import_smithy_client._json,
1314
+ NextToken: import_smithy_client.expectString
1315
+ });
1316
+ Object.assign(contents, doc);
1317
+ return contents;
1318
+ }, "de_ListConfigurationSetsCommand");
1889
1319
  var de_ListDedicatedIpPoolsCommand = /* @__PURE__ */ __name(async (output, context) => {
1890
1320
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1891
- return de_ListDedicatedIpPoolsCommandError(output, context);
1321
+ return de_CommandError(output, context);
1892
1322
  }
1893
1323
  const contents = (0, import_smithy_client.map)({
1894
1324
  $metadata: deserializeMetadata(output)
@@ -1901,31 +1331,9 @@ var de_ListDedicatedIpPoolsCommand = /* @__PURE__ */ __name(async (output, conte
1901
1331
  Object.assign(contents, doc);
1902
1332
  return contents;
1903
1333
  }, "de_ListDedicatedIpPoolsCommand");
1904
- var de_ListDedicatedIpPoolsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1905
- const parsedOutput = {
1906
- ...output,
1907
- body: await parseErrorBody(output.body, context)
1908
- };
1909
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1910
- switch (errorCode) {
1911
- case "BadRequestException":
1912
- case "com.amazonaws.pinpointemail#BadRequestException":
1913
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1914
- case "TooManyRequestsException":
1915
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1916
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1917
- default:
1918
- const parsedBody = parsedOutput.body;
1919
- return throwDefaultError({
1920
- output,
1921
- parsedBody,
1922
- errorCode
1923
- });
1924
- }
1925
- }, "de_ListDedicatedIpPoolsCommandError");
1926
1334
  var de_ListDeliverabilityTestReportsCommand = /* @__PURE__ */ __name(async (output, context) => {
1927
1335
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1928
- return de_ListDeliverabilityTestReportsCommandError(output, context);
1336
+ return de_CommandError(output, context);
1929
1337
  }
1930
1338
  const contents = (0, import_smithy_client.map)({
1931
1339
  $metadata: deserializeMetadata(output)
@@ -1938,34 +1346,9 @@ var de_ListDeliverabilityTestReportsCommand = /* @__PURE__ */ __name(async (outp
1938
1346
  Object.assign(contents, doc);
1939
1347
  return contents;
1940
1348
  }, "de_ListDeliverabilityTestReportsCommand");
1941
- var de_ListDeliverabilityTestReportsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1942
- const parsedOutput = {
1943
- ...output,
1944
- body: await parseErrorBody(output.body, context)
1945
- };
1946
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1947
- switch (errorCode) {
1948
- case "BadRequestException":
1949
- case "com.amazonaws.pinpointemail#BadRequestException":
1950
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1951
- case "NotFoundException":
1952
- case "com.amazonaws.pinpointemail#NotFoundException":
1953
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1954
- case "TooManyRequestsException":
1955
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1956
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1957
- default:
1958
- const parsedBody = parsedOutput.body;
1959
- return throwDefaultError({
1960
- output,
1961
- parsedBody,
1962
- errorCode
1963
- });
1964
- }
1965
- }, "de_ListDeliverabilityTestReportsCommandError");
1966
1349
  var de_ListDomainDeliverabilityCampaignsCommand = /* @__PURE__ */ __name(async (output, context) => {
1967
1350
  if (output.statusCode !== 200 && output.statusCode >= 300) {
1968
- return de_ListDomainDeliverabilityCampaignsCommandError(output, context);
1351
+ return de_CommandError(output, context);
1969
1352
  }
1970
1353
  const contents = (0, import_smithy_client.map)({
1971
1354
  $metadata: deserializeMetadata(output)
@@ -1978,34 +1361,9 @@ var de_ListDomainDeliverabilityCampaignsCommand = /* @__PURE__ */ __name(async (
1978
1361
  Object.assign(contents, doc);
1979
1362
  return contents;
1980
1363
  }, "de_ListDomainDeliverabilityCampaignsCommand");
1981
- var de_ListDomainDeliverabilityCampaignsCommandError = /* @__PURE__ */ __name(async (output, context) => {
1982
- const parsedOutput = {
1983
- ...output,
1984
- body: await parseErrorBody(output.body, context)
1985
- };
1986
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
1987
- switch (errorCode) {
1988
- case "BadRequestException":
1989
- case "com.amazonaws.pinpointemail#BadRequestException":
1990
- throw await de_BadRequestExceptionRes(parsedOutput, context);
1991
- case "NotFoundException":
1992
- case "com.amazonaws.pinpointemail#NotFoundException":
1993
- throw await de_NotFoundExceptionRes(parsedOutput, context);
1994
- case "TooManyRequestsException":
1995
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
1996
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1997
- default:
1998
- const parsedBody = parsedOutput.body;
1999
- return throwDefaultError({
2000
- output,
2001
- parsedBody,
2002
- errorCode
2003
- });
2004
- }
2005
- }, "de_ListDomainDeliverabilityCampaignsCommandError");
2006
1364
  var de_ListEmailIdentitiesCommand = /* @__PURE__ */ __name(async (output, context) => {
2007
1365
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2008
- return de_ListEmailIdentitiesCommandError(output, context);
1366
+ return de_CommandError(output, context);
2009
1367
  }
2010
1368
  const contents = (0, import_smithy_client.map)({
2011
1369
  $metadata: deserializeMetadata(output)
@@ -2018,31 +1376,9 @@ var de_ListEmailIdentitiesCommand = /* @__PURE__ */ __name(async (output, contex
2018
1376
  Object.assign(contents, doc);
2019
1377
  return contents;
2020
1378
  }, "de_ListEmailIdentitiesCommand");
2021
- var de_ListEmailIdentitiesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2022
- const parsedOutput = {
2023
- ...output,
2024
- body: await parseErrorBody(output.body, context)
2025
- };
2026
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2027
- switch (errorCode) {
2028
- case "BadRequestException":
2029
- case "com.amazonaws.pinpointemail#BadRequestException":
2030
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2031
- case "TooManyRequestsException":
2032
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2033
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2034
- default:
2035
- const parsedBody = parsedOutput.body;
2036
- return throwDefaultError({
2037
- output,
2038
- parsedBody,
2039
- errorCode
2040
- });
2041
- }
2042
- }, "de_ListEmailIdentitiesCommandError");
2043
1379
  var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
2044
1380
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2045
- return de_ListTagsForResourceCommandError(output, context);
1381
+ return de_CommandError(output, context);
2046
1382
  }
2047
1383
  const contents = (0, import_smithy_client.map)({
2048
1384
  $metadata: deserializeMetadata(output)
@@ -2054,34 +1390,9 @@ var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, contex
2054
1390
  Object.assign(contents, doc);
2055
1391
  return contents;
2056
1392
  }, "de_ListTagsForResourceCommand");
2057
- var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
2058
- const parsedOutput = {
2059
- ...output,
2060
- body: await parseErrorBody(output.body, context)
2061
- };
2062
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2063
- switch (errorCode) {
2064
- case "BadRequestException":
2065
- case "com.amazonaws.pinpointemail#BadRequestException":
2066
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2067
- case "NotFoundException":
2068
- case "com.amazonaws.pinpointemail#NotFoundException":
2069
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2070
- case "TooManyRequestsException":
2071
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2072
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2073
- default:
2074
- const parsedBody = parsedOutput.body;
2075
- return throwDefaultError({
2076
- output,
2077
- parsedBody,
2078
- errorCode
2079
- });
2080
- }
2081
- }, "de_ListTagsForResourceCommandError");
2082
1393
  var de_PutAccountDedicatedIpWarmupAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
2083
1394
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2084
- return de_PutAccountDedicatedIpWarmupAttributesCommandError(output, context);
1395
+ return de_CommandError(output, context);
2085
1396
  }
2086
1397
  const contents = (0, import_smithy_client.map)({
2087
1398
  $metadata: deserializeMetadata(output)
@@ -2089,31 +1400,9 @@ var de_PutAccountDedicatedIpWarmupAttributesCommand = /* @__PURE__ */ __name(asy
2089
1400
  await (0, import_smithy_client.collectBody)(output.body, context);
2090
1401
  return contents;
2091
1402
  }, "de_PutAccountDedicatedIpWarmupAttributesCommand");
2092
- var de_PutAccountDedicatedIpWarmupAttributesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2093
- const parsedOutput = {
2094
- ...output,
2095
- body: await parseErrorBody(output.body, context)
2096
- };
2097
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2098
- switch (errorCode) {
2099
- case "BadRequestException":
2100
- case "com.amazonaws.pinpointemail#BadRequestException":
2101
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2102
- case "TooManyRequestsException":
2103
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2104
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2105
- default:
2106
- const parsedBody = parsedOutput.body;
2107
- return throwDefaultError({
2108
- output,
2109
- parsedBody,
2110
- errorCode
2111
- });
2112
- }
2113
- }, "de_PutAccountDedicatedIpWarmupAttributesCommandError");
2114
1403
  var de_PutAccountSendingAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
2115
1404
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2116
- return de_PutAccountSendingAttributesCommandError(output, context);
1405
+ return de_CommandError(output, context);
2117
1406
  }
2118
1407
  const contents = (0, import_smithy_client.map)({
2119
1408
  $metadata: deserializeMetadata(output)
@@ -2121,31 +1410,9 @@ var de_PutAccountSendingAttributesCommand = /* @__PURE__ */ __name(async (output
2121
1410
  await (0, import_smithy_client.collectBody)(output.body, context);
2122
1411
  return contents;
2123
1412
  }, "de_PutAccountSendingAttributesCommand");
2124
- var de_PutAccountSendingAttributesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2125
- const parsedOutput = {
2126
- ...output,
2127
- body: await parseErrorBody(output.body, context)
2128
- };
2129
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2130
- switch (errorCode) {
2131
- case "BadRequestException":
2132
- case "com.amazonaws.pinpointemail#BadRequestException":
2133
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2134
- case "TooManyRequestsException":
2135
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2136
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2137
- default:
2138
- const parsedBody = parsedOutput.body;
2139
- return throwDefaultError({
2140
- output,
2141
- parsedBody,
2142
- errorCode
2143
- });
2144
- }
2145
- }, "de_PutAccountSendingAttributesCommandError");
2146
1413
  var de_PutConfigurationSetDeliveryOptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
2147
1414
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2148
- return de_PutConfigurationSetDeliveryOptionsCommandError(output, context);
1415
+ return de_CommandError(output, context);
2149
1416
  }
2150
1417
  const contents = (0, import_smithy_client.map)({
2151
1418
  $metadata: deserializeMetadata(output)
@@ -2153,34 +1420,9 @@ var de_PutConfigurationSetDeliveryOptionsCommand = /* @__PURE__ */ __name(async
2153
1420
  await (0, import_smithy_client.collectBody)(output.body, context);
2154
1421
  return contents;
2155
1422
  }, "de_PutConfigurationSetDeliveryOptionsCommand");
2156
- var de_PutConfigurationSetDeliveryOptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2157
- const parsedOutput = {
2158
- ...output,
2159
- body: await parseErrorBody(output.body, context)
2160
- };
2161
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2162
- switch (errorCode) {
2163
- case "BadRequestException":
2164
- case "com.amazonaws.pinpointemail#BadRequestException":
2165
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2166
- case "NotFoundException":
2167
- case "com.amazonaws.pinpointemail#NotFoundException":
2168
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2169
- case "TooManyRequestsException":
2170
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2171
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2172
- default:
2173
- const parsedBody = parsedOutput.body;
2174
- return throwDefaultError({
2175
- output,
2176
- parsedBody,
2177
- errorCode
2178
- });
2179
- }
2180
- }, "de_PutConfigurationSetDeliveryOptionsCommandError");
2181
1423
  var de_PutConfigurationSetReputationOptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
2182
1424
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2183
- return de_PutConfigurationSetReputationOptionsCommandError(output, context);
1425
+ return de_CommandError(output, context);
2184
1426
  }
2185
1427
  const contents = (0, import_smithy_client.map)({
2186
1428
  $metadata: deserializeMetadata(output)
@@ -2188,34 +1430,9 @@ var de_PutConfigurationSetReputationOptionsCommand = /* @__PURE__ */ __name(asyn
2188
1430
  await (0, import_smithy_client.collectBody)(output.body, context);
2189
1431
  return contents;
2190
1432
  }, "de_PutConfigurationSetReputationOptionsCommand");
2191
- var de_PutConfigurationSetReputationOptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2192
- const parsedOutput = {
2193
- ...output,
2194
- body: await parseErrorBody(output.body, context)
2195
- };
2196
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2197
- switch (errorCode) {
2198
- case "BadRequestException":
2199
- case "com.amazonaws.pinpointemail#BadRequestException":
2200
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2201
- case "NotFoundException":
2202
- case "com.amazonaws.pinpointemail#NotFoundException":
2203
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2204
- case "TooManyRequestsException":
2205
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2206
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2207
- default:
2208
- const parsedBody = parsedOutput.body;
2209
- return throwDefaultError({
2210
- output,
2211
- parsedBody,
2212
- errorCode
2213
- });
2214
- }
2215
- }, "de_PutConfigurationSetReputationOptionsCommandError");
2216
1433
  var de_PutConfigurationSetSendingOptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
2217
1434
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2218
- return de_PutConfigurationSetSendingOptionsCommandError(output, context);
1435
+ return de_CommandError(output, context);
2219
1436
  }
2220
1437
  const contents = (0, import_smithy_client.map)({
2221
1438
  $metadata: deserializeMetadata(output)
@@ -2223,69 +1440,19 @@ var de_PutConfigurationSetSendingOptionsCommand = /* @__PURE__ */ __name(async (
2223
1440
  await (0, import_smithy_client.collectBody)(output.body, context);
2224
1441
  return contents;
2225
1442
  }, "de_PutConfigurationSetSendingOptionsCommand");
2226
- var de_PutConfigurationSetSendingOptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2227
- const parsedOutput = {
2228
- ...output,
2229
- body: await parseErrorBody(output.body, context)
2230
- };
2231
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2232
- switch (errorCode) {
2233
- case "BadRequestException":
2234
- case "com.amazonaws.pinpointemail#BadRequestException":
2235
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2236
- case "NotFoundException":
2237
- case "com.amazonaws.pinpointemail#NotFoundException":
2238
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2239
- case "TooManyRequestsException":
2240
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2241
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2242
- default:
2243
- const parsedBody = parsedOutput.body;
2244
- return throwDefaultError({
2245
- output,
2246
- parsedBody,
2247
- errorCode
2248
- });
2249
- }
2250
- }, "de_PutConfigurationSetSendingOptionsCommandError");
2251
1443
  var de_PutConfigurationSetTrackingOptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
2252
1444
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2253
- return de_PutConfigurationSetTrackingOptionsCommandError(output, context);
1445
+ return de_CommandError(output, context);
2254
1446
  }
2255
1447
  const contents = (0, import_smithy_client.map)({
2256
1448
  $metadata: deserializeMetadata(output)
2257
1449
  });
2258
1450
  await (0, import_smithy_client.collectBody)(output.body, context);
2259
1451
  return contents;
2260
- }, "de_PutConfigurationSetTrackingOptionsCommand");
2261
- var de_PutConfigurationSetTrackingOptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
2262
- const parsedOutput = {
2263
- ...output,
2264
- body: await parseErrorBody(output.body, context)
2265
- };
2266
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2267
- switch (errorCode) {
2268
- case "BadRequestException":
2269
- case "com.amazonaws.pinpointemail#BadRequestException":
2270
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2271
- case "NotFoundException":
2272
- case "com.amazonaws.pinpointemail#NotFoundException":
2273
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2274
- case "TooManyRequestsException":
2275
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2276
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2277
- default:
2278
- const parsedBody = parsedOutput.body;
2279
- return throwDefaultError({
2280
- output,
2281
- parsedBody,
2282
- errorCode
2283
- });
2284
- }
2285
- }, "de_PutConfigurationSetTrackingOptionsCommandError");
1452
+ }, "de_PutConfigurationSetTrackingOptionsCommand");
2286
1453
  var de_PutDedicatedIpInPoolCommand = /* @__PURE__ */ __name(async (output, context) => {
2287
1454
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2288
- return de_PutDedicatedIpInPoolCommandError(output, context);
1455
+ return de_CommandError(output, context);
2289
1456
  }
2290
1457
  const contents = (0, import_smithy_client.map)({
2291
1458
  $metadata: deserializeMetadata(output)
@@ -2293,34 +1460,9 @@ var de_PutDedicatedIpInPoolCommand = /* @__PURE__ */ __name(async (output, conte
2293
1460
  await (0, import_smithy_client.collectBody)(output.body, context);
2294
1461
  return contents;
2295
1462
  }, "de_PutDedicatedIpInPoolCommand");
2296
- var de_PutDedicatedIpInPoolCommandError = /* @__PURE__ */ __name(async (output, context) => {
2297
- const parsedOutput = {
2298
- ...output,
2299
- body: await parseErrorBody(output.body, context)
2300
- };
2301
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2302
- switch (errorCode) {
2303
- case "BadRequestException":
2304
- case "com.amazonaws.pinpointemail#BadRequestException":
2305
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2306
- case "NotFoundException":
2307
- case "com.amazonaws.pinpointemail#NotFoundException":
2308
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2309
- case "TooManyRequestsException":
2310
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2311
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2312
- default:
2313
- const parsedBody = parsedOutput.body;
2314
- return throwDefaultError({
2315
- output,
2316
- parsedBody,
2317
- errorCode
2318
- });
2319
- }
2320
- }, "de_PutDedicatedIpInPoolCommandError");
2321
1463
  var de_PutDedicatedIpWarmupAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
2322
1464
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2323
- return de_PutDedicatedIpWarmupAttributesCommandError(output, context);
1465
+ return de_CommandError(output, context);
2324
1466
  }
2325
1467
  const contents = (0, import_smithy_client.map)({
2326
1468
  $metadata: deserializeMetadata(output)
@@ -2328,34 +1470,9 @@ var de_PutDedicatedIpWarmupAttributesCommand = /* @__PURE__ */ __name(async (out
2328
1470
  await (0, import_smithy_client.collectBody)(output.body, context);
2329
1471
  return contents;
2330
1472
  }, "de_PutDedicatedIpWarmupAttributesCommand");
2331
- var de_PutDedicatedIpWarmupAttributesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2332
- const parsedOutput = {
2333
- ...output,
2334
- body: await parseErrorBody(output.body, context)
2335
- };
2336
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2337
- switch (errorCode) {
2338
- case "BadRequestException":
2339
- case "com.amazonaws.pinpointemail#BadRequestException":
2340
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2341
- case "NotFoundException":
2342
- case "com.amazonaws.pinpointemail#NotFoundException":
2343
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2344
- case "TooManyRequestsException":
2345
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2346
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2347
- default:
2348
- const parsedBody = parsedOutput.body;
2349
- return throwDefaultError({
2350
- output,
2351
- parsedBody,
2352
- errorCode
2353
- });
2354
- }
2355
- }, "de_PutDedicatedIpWarmupAttributesCommandError");
2356
1473
  var de_PutDeliverabilityDashboardOptionCommand = /* @__PURE__ */ __name(async (output, context) => {
2357
1474
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2358
- return de_PutDeliverabilityDashboardOptionCommandError(output, context);
1475
+ return de_CommandError(output, context);
2359
1476
  }
2360
1477
  const contents = (0, import_smithy_client.map)({
2361
1478
  $metadata: deserializeMetadata(output)
@@ -2363,40 +1480,9 @@ var de_PutDeliverabilityDashboardOptionCommand = /* @__PURE__ */ __name(async (o
2363
1480
  await (0, import_smithy_client.collectBody)(output.body, context);
2364
1481
  return contents;
2365
1482
  }, "de_PutDeliverabilityDashboardOptionCommand");
2366
- var de_PutDeliverabilityDashboardOptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
2367
- const parsedOutput = {
2368
- ...output,
2369
- body: await parseErrorBody(output.body, context)
2370
- };
2371
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2372
- switch (errorCode) {
2373
- case "AlreadyExistsException":
2374
- case "com.amazonaws.pinpointemail#AlreadyExistsException":
2375
- throw await de_AlreadyExistsExceptionRes(parsedOutput, context);
2376
- case "BadRequestException":
2377
- case "com.amazonaws.pinpointemail#BadRequestException":
2378
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2379
- case "LimitExceededException":
2380
- case "com.amazonaws.pinpointemail#LimitExceededException":
2381
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2382
- case "NotFoundException":
2383
- case "com.amazonaws.pinpointemail#NotFoundException":
2384
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2385
- case "TooManyRequestsException":
2386
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2387
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2388
- default:
2389
- const parsedBody = parsedOutput.body;
2390
- return throwDefaultError({
2391
- output,
2392
- parsedBody,
2393
- errorCode
2394
- });
2395
- }
2396
- }, "de_PutDeliverabilityDashboardOptionCommandError");
2397
1483
  var de_PutEmailIdentityDkimAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
2398
1484
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2399
- return de_PutEmailIdentityDkimAttributesCommandError(output, context);
1485
+ return de_CommandError(output, context);
2400
1486
  }
2401
1487
  const contents = (0, import_smithy_client.map)({
2402
1488
  $metadata: deserializeMetadata(output)
@@ -2404,34 +1490,9 @@ var de_PutEmailIdentityDkimAttributesCommand = /* @__PURE__ */ __name(async (out
2404
1490
  await (0, import_smithy_client.collectBody)(output.body, context);
2405
1491
  return contents;
2406
1492
  }, "de_PutEmailIdentityDkimAttributesCommand");
2407
- var de_PutEmailIdentityDkimAttributesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2408
- const parsedOutput = {
2409
- ...output,
2410
- body: await parseErrorBody(output.body, context)
2411
- };
2412
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2413
- switch (errorCode) {
2414
- case "BadRequestException":
2415
- case "com.amazonaws.pinpointemail#BadRequestException":
2416
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2417
- case "NotFoundException":
2418
- case "com.amazonaws.pinpointemail#NotFoundException":
2419
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2420
- case "TooManyRequestsException":
2421
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2422
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2423
- default:
2424
- const parsedBody = parsedOutput.body;
2425
- return throwDefaultError({
2426
- output,
2427
- parsedBody,
2428
- errorCode
2429
- });
2430
- }
2431
- }, "de_PutEmailIdentityDkimAttributesCommandError");
2432
1493
  var de_PutEmailIdentityFeedbackAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
2433
1494
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2434
- return de_PutEmailIdentityFeedbackAttributesCommandError(output, context);
1495
+ return de_CommandError(output, context);
2435
1496
  }
2436
1497
  const contents = (0, import_smithy_client.map)({
2437
1498
  $metadata: deserializeMetadata(output)
@@ -2439,34 +1500,9 @@ var de_PutEmailIdentityFeedbackAttributesCommand = /* @__PURE__ */ __name(async
2439
1500
  await (0, import_smithy_client.collectBody)(output.body, context);
2440
1501
  return contents;
2441
1502
  }, "de_PutEmailIdentityFeedbackAttributesCommand");
2442
- var de_PutEmailIdentityFeedbackAttributesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2443
- const parsedOutput = {
2444
- ...output,
2445
- body: await parseErrorBody(output.body, context)
2446
- };
2447
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2448
- switch (errorCode) {
2449
- case "BadRequestException":
2450
- case "com.amazonaws.pinpointemail#BadRequestException":
2451
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2452
- case "NotFoundException":
2453
- case "com.amazonaws.pinpointemail#NotFoundException":
2454
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2455
- case "TooManyRequestsException":
2456
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2457
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2458
- default:
2459
- const parsedBody = parsedOutput.body;
2460
- return throwDefaultError({
2461
- output,
2462
- parsedBody,
2463
- errorCode
2464
- });
2465
- }
2466
- }, "de_PutEmailIdentityFeedbackAttributesCommandError");
2467
1503
  var de_PutEmailIdentityMailFromAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
2468
1504
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2469
- return de_PutEmailIdentityMailFromAttributesCommandError(output, context);
1505
+ return de_CommandError(output, context);
2470
1506
  }
2471
1507
  const contents = (0, import_smithy_client.map)({
2472
1508
  $metadata: deserializeMetadata(output)
@@ -2474,34 +1510,9 @@ var de_PutEmailIdentityMailFromAttributesCommand = /* @__PURE__ */ __name(async
2474
1510
  await (0, import_smithy_client.collectBody)(output.body, context);
2475
1511
  return contents;
2476
1512
  }, "de_PutEmailIdentityMailFromAttributesCommand");
2477
- var de_PutEmailIdentityMailFromAttributesCommandError = /* @__PURE__ */ __name(async (output, context) => {
2478
- const parsedOutput = {
2479
- ...output,
2480
- body: await parseErrorBody(output.body, context)
2481
- };
2482
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2483
- switch (errorCode) {
2484
- case "BadRequestException":
2485
- case "com.amazonaws.pinpointemail#BadRequestException":
2486
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2487
- case "NotFoundException":
2488
- case "com.amazonaws.pinpointemail#NotFoundException":
2489
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2490
- case "TooManyRequestsException":
2491
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2492
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2493
- default:
2494
- const parsedBody = parsedOutput.body;
2495
- return throwDefaultError({
2496
- output,
2497
- parsedBody,
2498
- errorCode
2499
- });
2500
- }
2501
- }, "de_PutEmailIdentityMailFromAttributesCommandError");
2502
1513
  var de_SendEmailCommand = /* @__PURE__ */ __name(async (output, context) => {
2503
1514
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2504
- return de_SendEmailCommandError(output, context);
1515
+ return de_CommandError(output, context);
2505
1516
  }
2506
1517
  const contents = (0, import_smithy_client.map)({
2507
1518
  $metadata: deserializeMetadata(output)
@@ -2513,49 +1524,9 @@ var de_SendEmailCommand = /* @__PURE__ */ __name(async (output, context) => {
2513
1524
  Object.assign(contents, doc);
2514
1525
  return contents;
2515
1526
  }, "de_SendEmailCommand");
2516
- var de_SendEmailCommandError = /* @__PURE__ */ __name(async (output, context) => {
2517
- const parsedOutput = {
2518
- ...output,
2519
- body: await parseErrorBody(output.body, context)
2520
- };
2521
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2522
- switch (errorCode) {
2523
- case "AccountSuspendedException":
2524
- case "com.amazonaws.pinpointemail#AccountSuspendedException":
2525
- throw await de_AccountSuspendedExceptionRes(parsedOutput, context);
2526
- case "BadRequestException":
2527
- case "com.amazonaws.pinpointemail#BadRequestException":
2528
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2529
- case "LimitExceededException":
2530
- case "com.amazonaws.pinpointemail#LimitExceededException":
2531
- throw await de_LimitExceededExceptionRes(parsedOutput, context);
2532
- case "MailFromDomainNotVerifiedException":
2533
- case "com.amazonaws.pinpointemail#MailFromDomainNotVerifiedException":
2534
- throw await de_MailFromDomainNotVerifiedExceptionRes(parsedOutput, context);
2535
- case "MessageRejected":
2536
- case "com.amazonaws.pinpointemail#MessageRejected":
2537
- throw await de_MessageRejectedRes(parsedOutput, context);
2538
- case "NotFoundException":
2539
- case "com.amazonaws.pinpointemail#NotFoundException":
2540
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2541
- case "SendingPausedException":
2542
- case "com.amazonaws.pinpointemail#SendingPausedException":
2543
- throw await de_SendingPausedExceptionRes(parsedOutput, context);
2544
- case "TooManyRequestsException":
2545
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2546
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2547
- default:
2548
- const parsedBody = parsedOutput.body;
2549
- return throwDefaultError({
2550
- output,
2551
- parsedBody,
2552
- errorCode
2553
- });
2554
- }
2555
- }, "de_SendEmailCommandError");
2556
1527
  var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
2557
1528
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2558
- return de_TagResourceCommandError(output, context);
1529
+ return de_CommandError(output, context);
2559
1530
  }
2560
1531
  const contents = (0, import_smithy_client.map)({
2561
1532
  $metadata: deserializeMetadata(output)
@@ -2563,37 +1534,9 @@ var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
2563
1534
  await (0, import_smithy_client.collectBody)(output.body, context);
2564
1535
  return contents;
2565
1536
  }, "de_TagResourceCommand");
2566
- var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
2567
- const parsedOutput = {
2568
- ...output,
2569
- body: await parseErrorBody(output.body, context)
2570
- };
2571
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2572
- switch (errorCode) {
2573
- case "BadRequestException":
2574
- case "com.amazonaws.pinpointemail#BadRequestException":
2575
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2576
- case "ConcurrentModificationException":
2577
- case "com.amazonaws.pinpointemail#ConcurrentModificationException":
2578
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2579
- case "NotFoundException":
2580
- case "com.amazonaws.pinpointemail#NotFoundException":
2581
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2582
- case "TooManyRequestsException":
2583
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2584
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2585
- default:
2586
- const parsedBody = parsedOutput.body;
2587
- return throwDefaultError({
2588
- output,
2589
- parsedBody,
2590
- errorCode
2591
- });
2592
- }
2593
- }, "de_TagResourceCommandError");
2594
1537
  var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
2595
1538
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2596
- return de_UntagResourceCommandError(output, context);
1539
+ return de_CommandError(output, context);
2597
1540
  }
2598
1541
  const contents = (0, import_smithy_client.map)({
2599
1542
  $metadata: deserializeMetadata(output)
@@ -2601,37 +1544,9 @@ var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) =>
2601
1544
  await (0, import_smithy_client.collectBody)(output.body, context);
2602
1545
  return contents;
2603
1546
  }, "de_UntagResourceCommand");
2604
- var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
2605
- const parsedOutput = {
2606
- ...output,
2607
- body: await parseErrorBody(output.body, context)
2608
- };
2609
- const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2610
- switch (errorCode) {
2611
- case "BadRequestException":
2612
- case "com.amazonaws.pinpointemail#BadRequestException":
2613
- throw await de_BadRequestExceptionRes(parsedOutput, context);
2614
- case "ConcurrentModificationException":
2615
- case "com.amazonaws.pinpointemail#ConcurrentModificationException":
2616
- throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
2617
- case "NotFoundException":
2618
- case "com.amazonaws.pinpointemail#NotFoundException":
2619
- throw await de_NotFoundExceptionRes(parsedOutput, context);
2620
- case "TooManyRequestsException":
2621
- case "com.amazonaws.pinpointemail#TooManyRequestsException":
2622
- throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
2623
- default:
2624
- const parsedBody = parsedOutput.body;
2625
- return throwDefaultError({
2626
- output,
2627
- parsedBody,
2628
- errorCode
2629
- });
2630
- }
2631
- }, "de_UntagResourceCommandError");
2632
1547
  var de_UpdateConfigurationSetEventDestinationCommand = /* @__PURE__ */ __name(async (output, context) => {
2633
1548
  if (output.statusCode !== 200 && output.statusCode >= 300) {
2634
- return de_UpdateConfigurationSetEventDestinationCommandError(output, context);
1549
+ return de_CommandError(output, context);
2635
1550
  }
2636
1551
  const contents = (0, import_smithy_client.map)({
2637
1552
  $metadata: deserializeMetadata(output)
@@ -2639,22 +1554,43 @@ var de_UpdateConfigurationSetEventDestinationCommand = /* @__PURE__ */ __name(as
2639
1554
  await (0, import_smithy_client.collectBody)(output.body, context);
2640
1555
  return contents;
2641
1556
  }, "de_UpdateConfigurationSetEventDestinationCommand");
2642
- var de_UpdateConfigurationSetEventDestinationCommandError = /* @__PURE__ */ __name(async (output, context) => {
1557
+ var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
2643
1558
  const parsedOutput = {
2644
1559
  ...output,
2645
1560
  body: await parseErrorBody(output.body, context)
2646
1561
  };
2647
1562
  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
2648
1563
  switch (errorCode) {
1564
+ case "AlreadyExistsException":
1565
+ case "com.amazonaws.pinpointemail#AlreadyExistsException":
1566
+ throw await de_AlreadyExistsExceptionRes(parsedOutput, context);
2649
1567
  case "BadRequestException":
2650
1568
  case "com.amazonaws.pinpointemail#BadRequestException":
2651
1569
  throw await de_BadRequestExceptionRes(parsedOutput, context);
1570
+ case "ConcurrentModificationException":
1571
+ case "com.amazonaws.pinpointemail#ConcurrentModificationException":
1572
+ throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
1573
+ case "LimitExceededException":
1574
+ case "com.amazonaws.pinpointemail#LimitExceededException":
1575
+ throw await de_LimitExceededExceptionRes(parsedOutput, context);
2652
1576
  case "NotFoundException":
2653
1577
  case "com.amazonaws.pinpointemail#NotFoundException":
2654
1578
  throw await de_NotFoundExceptionRes(parsedOutput, context);
2655
1579
  case "TooManyRequestsException":
2656
1580
  case "com.amazonaws.pinpointemail#TooManyRequestsException":
2657
1581
  throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
1582
+ case "AccountSuspendedException":
1583
+ case "com.amazonaws.pinpointemail#AccountSuspendedException":
1584
+ throw await de_AccountSuspendedExceptionRes(parsedOutput, context);
1585
+ case "MailFromDomainNotVerifiedException":
1586
+ case "com.amazonaws.pinpointemail#MailFromDomainNotVerifiedException":
1587
+ throw await de_MailFromDomainNotVerifiedExceptionRes(parsedOutput, context);
1588
+ case "MessageRejected":
1589
+ case "com.amazonaws.pinpointemail#MessageRejected":
1590
+ throw await de_MessageRejectedRes(parsedOutput, context);
1591
+ case "SendingPausedException":
1592
+ case "com.amazonaws.pinpointemail#SendingPausedException":
1593
+ throw await de_SendingPausedExceptionRes(parsedOutput, context);
2658
1594
  default:
2659
1595
  const parsedBody = parsedOutput.body;
2660
1596
  return throwDefaultError({
@@ -2663,7 +1599,7 @@ var de_UpdateConfigurationSetEventDestinationCommandError = /* @__PURE__ */ __na
2663
1599
  errorCode
2664
1600
  });
2665
1601
  }
2666
- }, "de_UpdateConfigurationSetEventDestinationCommandError");
1602
+ }, "de_CommandError");
2667
1603
  var throwDefaultError = (0, import_smithy_client.withBaseException)(PinpointEmailServiceException);
2668
1604
  var de_AccountSuspendedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
2669
1605
  const contents = (0, import_smithy_client.map)({});