@aws-sdk/client-s3-control 3.783.0 → 3.796.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 +0 -1105
  2. package/dist-es/protocols/Aws_restXml.js +0 -1105
  3. package/package.json +7 -7
package/dist-cjs/index.js CHANGED
@@ -362,7 +362,6 @@ var import_core2 = require("@aws-sdk/core");
362
362
  var import_xml_builder = require("@aws-sdk/xml-builder");
363
363
 
364
364
 
365
-
366
365
  var import_uuid = require("uuid");
367
366
 
368
367
  // src/models/models_0.ts
@@ -929,18 +928,6 @@ var se_AssociateAccessGrantsIdentityCenterCommand = /* @__PURE__ */ __name(async
929
928
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
930
929
  bn.cc(input, _ICA);
931
930
  body += bn.toString();
932
- let { hostname: resolvedHostname } = await context.endpoint();
933
- if (context.disableHostPrefix !== true) {
934
- resolvedHostname = "{AccountId}." + resolvedHostname;
935
- if (input.AccountId === void 0) {
936
- throw new Error("Empty value provided for input host prefix: AccountId.");
937
- }
938
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
939
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
940
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
941
- }
942
- }
943
- b.hn(resolvedHostname);
944
931
  b.m("POST").h(headers).b(body);
945
932
  return b.build();
946
933
  }, "se_AssociateAccessGrantsIdentityCenterCommand");
@@ -969,18 +956,6 @@ var se_CreateAccessGrantCommand = /* @__PURE__ */ __name(async (input, context)
969
956
  bn.cc(input, _SPT);
970
957
  bn.lc(input, "Tags", "Tags", () => se_TagList(input[_T], context));
971
958
  body += bn.toString();
972
- let { hostname: resolvedHostname } = await context.endpoint();
973
- if (context.disableHostPrefix !== true) {
974
- resolvedHostname = "{AccountId}." + resolvedHostname;
975
- if (input.AccountId === void 0) {
976
- throw new Error("Empty value provided for input host prefix: AccountId.");
977
- }
978
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
979
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
980
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
981
- }
982
- }
983
- b.hn(resolvedHostname);
984
959
  b.m("POST").h(headers).b(body);
985
960
  return b.build();
986
961
  }, "se_CreateAccessGrantCommand");
@@ -998,18 +973,6 @@ var se_CreateAccessGrantsInstanceCommand = /* @__PURE__ */ __name(async (input,
998
973
  bn.cc(input, _ICA);
999
974
  bn.lc(input, "Tags", "Tags", () => se_TagList(input[_T], context));
1000
975
  body += bn.toString();
1001
- let { hostname: resolvedHostname } = await context.endpoint();
1002
- if (context.disableHostPrefix !== true) {
1003
- resolvedHostname = "{AccountId}." + resolvedHostname;
1004
- if (input.AccountId === void 0) {
1005
- throw new Error("Empty value provided for input host prefix: AccountId.");
1006
- }
1007
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1008
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1009
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1010
- }
1011
- }
1012
- b.hn(resolvedHostname);
1013
976
  b.m("POST").h(headers).b(body);
1014
977
  return b.build();
1015
978
  }, "se_CreateAccessGrantsInstanceCommand");
@@ -1030,18 +993,6 @@ var se_CreateAccessGrantsLocationCommand = /* @__PURE__ */ __name(async (input,
1030
993
  }
1031
994
  bn.lc(input, "Tags", "Tags", () => se_TagList(input[_T], context));
1032
995
  body += bn.toString();
1033
- let { hostname: resolvedHostname } = await context.endpoint();
1034
- if (context.disableHostPrefix !== true) {
1035
- resolvedHostname = "{AccountId}." + resolvedHostname;
1036
- if (input.AccountId === void 0) {
1037
- throw new Error("Empty value provided for input host prefix: AccountId.");
1038
- }
1039
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1040
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1041
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1042
- }
1043
- }
1044
- b.hn(resolvedHostname);
1045
996
  b.m("POST").h(headers).b(body);
1046
997
  return b.build();
1047
998
  }, "se_CreateAccessGrantsLocationCommand");
@@ -1073,18 +1024,6 @@ var se_CreateAccessPointCommand = /* @__PURE__ */ __name(async (input, context)
1073
1024
  bn.c(se_VpcConfiguration(input[_VC], context).n(_VC));
1074
1025
  }
1075
1026
  body += bn.toString();
1076
- let { hostname: resolvedHostname } = await context.endpoint();
1077
- if (context.disableHostPrefix !== true) {
1078
- resolvedHostname = "{AccountId}." + resolvedHostname;
1079
- if (input.AccountId === void 0) {
1080
- throw new Error("Empty value provided for input host prefix: AccountId.");
1081
- }
1082
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1083
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1084
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1085
- }
1086
- }
1087
- b.hn(resolvedHostname);
1088
1027
  b.m("PUT").h(headers).b(body);
1089
1028
  return b.build();
1090
1029
  }, "se_CreateAccessPointCommand");
@@ -1104,18 +1043,6 @@ var se_CreateAccessPointForObjectLambdaCommand = /* @__PURE__ */ __name(async (i
1104
1043
  bn.c(se_ObjectLambdaConfiguration(input[_C], context).n(_C));
1105
1044
  }
1106
1045
  body += bn.toString();
1107
- let { hostname: resolvedHostname } = await context.endpoint();
1108
- if (context.disableHostPrefix !== true) {
1109
- resolvedHostname = "{AccountId}." + resolvedHostname;
1110
- if (input.AccountId === void 0) {
1111
- throw new Error("Empty value provided for input host prefix: AccountId.");
1112
- }
1113
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1114
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1115
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1116
- }
1117
- }
1118
- b.hn(resolvedHostname);
1119
1046
  b.m("PUT").h(headers).b(body);
1120
1047
  return b.build();
1121
1048
  }, "se_CreateAccessPointForObjectLambdaCommand");
@@ -1188,18 +1115,6 @@ var se_CreateJobCommand = /* @__PURE__ */ __name(async (input, context) => {
1188
1115
  }
1189
1116
  bn.lc(input, "Tags", "Tags", () => se_S3TagSet(input[_T], context));
1190
1117
  body += bn.toString();
1191
- let { hostname: resolvedHostname } = await context.endpoint();
1192
- if (context.disableHostPrefix !== true) {
1193
- resolvedHostname = "{AccountId}." + resolvedHostname;
1194
- if (input.AccountId === void 0) {
1195
- throw new Error("Empty value provided for input host prefix: AccountId.");
1196
- }
1197
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1198
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1199
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1200
- }
1201
- }
1202
- b.hn(resolvedHostname);
1203
1118
  b.m("POST").h(headers).b(body);
1204
1119
  return b.build();
1205
1120
  }, "se_CreateJobCommand");
@@ -1224,18 +1139,6 @@ var se_CreateMultiRegionAccessPointCommand = /* @__PURE__ */ __name(async (input
1224
1139
  bn.c(se_CreateMultiRegionAccessPointInput(input[_De], context).n(_De));
1225
1140
  }
1226
1141
  body += bn.toString();
1227
- let { hostname: resolvedHostname } = await context.endpoint();
1228
- if (context.disableHostPrefix !== true) {
1229
- resolvedHostname = "{AccountId}." + resolvedHostname;
1230
- if (input.AccountId === void 0) {
1231
- throw new Error("Empty value provided for input host prefix: AccountId.");
1232
- }
1233
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1234
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1235
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1236
- }
1237
- }
1238
- b.hn(resolvedHostname);
1239
1142
  b.m("POST").h(headers).b(body);
1240
1143
  return b.build();
1241
1144
  }, "se_CreateMultiRegionAccessPointCommand");
@@ -1255,18 +1158,6 @@ var se_CreateStorageLensGroupCommand = /* @__PURE__ */ __name(async (input, cont
1255
1158
  }
1256
1159
  bn.lc(input, "Tags", "Tags", () => se_TagList(input[_T], context));
1257
1160
  body += bn.toString();
1258
- let { hostname: resolvedHostname } = await context.endpoint();
1259
- if (context.disableHostPrefix !== true) {
1260
- resolvedHostname = "{AccountId}." + resolvedHostname;
1261
- if (input.AccountId === void 0) {
1262
- throw new Error("Empty value provided for input host prefix: AccountId.");
1263
- }
1264
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1265
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1266
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1267
- }
1268
- }
1269
- b.hn(resolvedHostname);
1270
1161
  b.m("POST").h(headers).b(body);
1271
1162
  return b.build();
1272
1163
  }, "se_CreateStorageLensGroupCommand");
@@ -1278,18 +1169,6 @@ var se_DeleteAccessGrantCommand = /* @__PURE__ */ __name(async (input, context)
1278
1169
  b.bp("/v20180820/accessgrantsinstance/grant/{AccessGrantId}");
1279
1170
  b.p("AccessGrantId", () => input.AccessGrantId, "{AccessGrantId}", false);
1280
1171
  let body;
1281
- let { hostname: resolvedHostname } = await context.endpoint();
1282
- if (context.disableHostPrefix !== true) {
1283
- resolvedHostname = "{AccountId}." + resolvedHostname;
1284
- if (input.AccountId === void 0) {
1285
- throw new Error("Empty value provided for input host prefix: AccountId.");
1286
- }
1287
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1288
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1289
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1290
- }
1291
- }
1292
- b.hn(resolvedHostname);
1293
1172
  b.m("DELETE").h(headers).b(body);
1294
1173
  return b.build();
1295
1174
  }, "se_DeleteAccessGrantCommand");
@@ -1300,18 +1179,6 @@ var se_DeleteAccessGrantsInstanceCommand = /* @__PURE__ */ __name(async (input,
1300
1179
  });
1301
1180
  b.bp("/v20180820/accessgrantsinstance");
1302
1181
  let body;
1303
- let { hostname: resolvedHostname } = await context.endpoint();
1304
- if (context.disableHostPrefix !== true) {
1305
- resolvedHostname = "{AccountId}." + resolvedHostname;
1306
- if (input.AccountId === void 0) {
1307
- throw new Error("Empty value provided for input host prefix: AccountId.");
1308
- }
1309
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1310
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1311
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1312
- }
1313
- }
1314
- b.hn(resolvedHostname);
1315
1182
  b.m("DELETE").h(headers).b(body);
1316
1183
  return b.build();
1317
1184
  }, "se_DeleteAccessGrantsInstanceCommand");
@@ -1322,18 +1189,6 @@ var se_DeleteAccessGrantsInstanceResourcePolicyCommand = /* @__PURE__ */ __name(
1322
1189
  });
1323
1190
  b.bp("/v20180820/accessgrantsinstance/resourcepolicy");
1324
1191
  let body;
1325
- let { hostname: resolvedHostname } = await context.endpoint();
1326
- if (context.disableHostPrefix !== true) {
1327
- resolvedHostname = "{AccountId}." + resolvedHostname;
1328
- if (input.AccountId === void 0) {
1329
- throw new Error("Empty value provided for input host prefix: AccountId.");
1330
- }
1331
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1332
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1333
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1334
- }
1335
- }
1336
- b.hn(resolvedHostname);
1337
1192
  b.m("DELETE").h(headers).b(body);
1338
1193
  return b.build();
1339
1194
  }, "se_DeleteAccessGrantsInstanceResourcePolicyCommand");
@@ -1345,18 +1200,6 @@ var se_DeleteAccessGrantsLocationCommand = /* @__PURE__ */ __name(async (input,
1345
1200
  b.bp("/v20180820/accessgrantsinstance/location/{AccessGrantsLocationId}");
1346
1201
  b.p("AccessGrantsLocationId", () => input.AccessGrantsLocationId, "{AccessGrantsLocationId}", false);
1347
1202
  let body;
1348
- let { hostname: resolvedHostname } = await context.endpoint();
1349
- if (context.disableHostPrefix !== true) {
1350
- resolvedHostname = "{AccountId}." + resolvedHostname;
1351
- if (input.AccountId === void 0) {
1352
- throw new Error("Empty value provided for input host prefix: AccountId.");
1353
- }
1354
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1355
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1356
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1357
- }
1358
- }
1359
- b.hn(resolvedHostname);
1360
1203
  b.m("DELETE").h(headers).b(body);
1361
1204
  return b.build();
1362
1205
  }, "se_DeleteAccessGrantsLocationCommand");
@@ -1368,18 +1211,6 @@ var se_DeleteAccessPointCommand = /* @__PURE__ */ __name(async (input, context)
1368
1211
  b.bp("/v20180820/accesspoint/{Name}");
1369
1212
  b.p("Name", () => input.Name, "{Name}", false);
1370
1213
  let body;
1371
- let { hostname: resolvedHostname } = await context.endpoint();
1372
- if (context.disableHostPrefix !== true) {
1373
- resolvedHostname = "{AccountId}." + resolvedHostname;
1374
- if (input.AccountId === void 0) {
1375
- throw new Error("Empty value provided for input host prefix: AccountId.");
1376
- }
1377
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1378
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1379
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1380
- }
1381
- }
1382
- b.hn(resolvedHostname);
1383
1214
  b.m("DELETE").h(headers).b(body);
1384
1215
  return b.build();
1385
1216
  }, "se_DeleteAccessPointCommand");
@@ -1391,18 +1222,6 @@ var se_DeleteAccessPointForObjectLambdaCommand = /* @__PURE__ */ __name(async (i
1391
1222
  b.bp("/v20180820/accesspointforobjectlambda/{Name}");
1392
1223
  b.p("Name", () => input.Name, "{Name}", false);
1393
1224
  let body;
1394
- let { hostname: resolvedHostname } = await context.endpoint();
1395
- if (context.disableHostPrefix !== true) {
1396
- resolvedHostname = "{AccountId}." + resolvedHostname;
1397
- if (input.AccountId === void 0) {
1398
- throw new Error("Empty value provided for input host prefix: AccountId.");
1399
- }
1400
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1401
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1402
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1403
- }
1404
- }
1405
- b.hn(resolvedHostname);
1406
1225
  b.m("DELETE").h(headers).b(body);
1407
1226
  return b.build();
1408
1227
  }, "se_DeleteAccessPointForObjectLambdaCommand");
@@ -1414,18 +1233,6 @@ var se_DeleteAccessPointPolicyCommand = /* @__PURE__ */ __name(async (input, con
1414
1233
  b.bp("/v20180820/accesspoint/{Name}/policy");
1415
1234
  b.p("Name", () => input.Name, "{Name}", false);
1416
1235
  let body;
1417
- let { hostname: resolvedHostname } = await context.endpoint();
1418
- if (context.disableHostPrefix !== true) {
1419
- resolvedHostname = "{AccountId}." + resolvedHostname;
1420
- if (input.AccountId === void 0) {
1421
- throw new Error("Empty value provided for input host prefix: AccountId.");
1422
- }
1423
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1424
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1425
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1426
- }
1427
- }
1428
- b.hn(resolvedHostname);
1429
1236
  b.m("DELETE").h(headers).b(body);
1430
1237
  return b.build();
1431
1238
  }, "se_DeleteAccessPointPolicyCommand");
@@ -1437,18 +1244,6 @@ var se_DeleteAccessPointPolicyForObjectLambdaCommand = /* @__PURE__ */ __name(as
1437
1244
  b.bp("/v20180820/accesspointforobjectlambda/{Name}/policy");
1438
1245
  b.p("Name", () => input.Name, "{Name}", false);
1439
1246
  let body;
1440
- let { hostname: resolvedHostname } = await context.endpoint();
1441
- if (context.disableHostPrefix !== true) {
1442
- resolvedHostname = "{AccountId}." + resolvedHostname;
1443
- if (input.AccountId === void 0) {
1444
- throw new Error("Empty value provided for input host prefix: AccountId.");
1445
- }
1446
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1447
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1448
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1449
- }
1450
- }
1451
- b.hn(resolvedHostname);
1452
1247
  b.m("DELETE").h(headers).b(body);
1453
1248
  return b.build();
1454
1249
  }, "se_DeleteAccessPointPolicyForObjectLambdaCommand");
@@ -1471,18 +1266,6 @@ var se_DeleteBucketCommand = /* @__PURE__ */ __name(async (input, context) => {
1471
1266
  b.bp("/v20180820/bucket/{Bucket}");
1472
1267
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
1473
1268
  let body;
1474
- let { hostname: resolvedHostname } = await context.endpoint();
1475
- if (context.disableHostPrefix !== true) {
1476
- resolvedHostname = "{AccountId}." + resolvedHostname;
1477
- if (input.AccountId === void 0) {
1478
- throw new Error("Empty value provided for input host prefix: AccountId.");
1479
- }
1480
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1481
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1482
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1483
- }
1484
- }
1485
- b.hn(resolvedHostname);
1486
1269
  b.m("DELETE").h(headers).b(body);
1487
1270
  return b.build();
1488
1271
  }, "se_DeleteBucketCommand");
@@ -1494,18 +1277,6 @@ var se_DeleteBucketLifecycleConfigurationCommand = /* @__PURE__ */ __name(async
1494
1277
  b.bp("/v20180820/bucket/{Bucket}/lifecycleconfiguration");
1495
1278
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
1496
1279
  let body;
1497
- let { hostname: resolvedHostname } = await context.endpoint();
1498
- if (context.disableHostPrefix !== true) {
1499
- resolvedHostname = "{AccountId}." + resolvedHostname;
1500
- if (input.AccountId === void 0) {
1501
- throw new Error("Empty value provided for input host prefix: AccountId.");
1502
- }
1503
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1504
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1505
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1506
- }
1507
- }
1508
- b.hn(resolvedHostname);
1509
1280
  b.m("DELETE").h(headers).b(body);
1510
1281
  return b.build();
1511
1282
  }, "se_DeleteBucketLifecycleConfigurationCommand");
@@ -1517,18 +1288,6 @@ var se_DeleteBucketPolicyCommand = /* @__PURE__ */ __name(async (input, context)
1517
1288
  b.bp("/v20180820/bucket/{Bucket}/policy");
1518
1289
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
1519
1290
  let body;
1520
- let { hostname: resolvedHostname } = await context.endpoint();
1521
- if (context.disableHostPrefix !== true) {
1522
- resolvedHostname = "{AccountId}." + resolvedHostname;
1523
- if (input.AccountId === void 0) {
1524
- throw new Error("Empty value provided for input host prefix: AccountId.");
1525
- }
1526
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1527
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1528
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1529
- }
1530
- }
1531
- b.hn(resolvedHostname);
1532
1291
  b.m("DELETE").h(headers).b(body);
1533
1292
  return b.build();
1534
1293
  }, "se_DeleteBucketPolicyCommand");
@@ -1540,18 +1299,6 @@ var se_DeleteBucketReplicationCommand = /* @__PURE__ */ __name(async (input, con
1540
1299
  b.bp("/v20180820/bucket/{Bucket}/replication");
1541
1300
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
1542
1301
  let body;
1543
- let { hostname: resolvedHostname } = await context.endpoint();
1544
- if (context.disableHostPrefix !== true) {
1545
- resolvedHostname = "{AccountId}." + resolvedHostname;
1546
- if (input.AccountId === void 0) {
1547
- throw new Error("Empty value provided for input host prefix: AccountId.");
1548
- }
1549
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1550
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1551
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1552
- }
1553
- }
1554
- b.hn(resolvedHostname);
1555
1302
  b.m("DELETE").h(headers).b(body);
1556
1303
  return b.build();
1557
1304
  }, "se_DeleteBucketReplicationCommand");
@@ -1563,18 +1310,6 @@ var se_DeleteBucketTaggingCommand = /* @__PURE__ */ __name(async (input, context
1563
1310
  b.bp("/v20180820/bucket/{Bucket}/tagging");
1564
1311
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
1565
1312
  let body;
1566
- let { hostname: resolvedHostname } = await context.endpoint();
1567
- if (context.disableHostPrefix !== true) {
1568
- resolvedHostname = "{AccountId}." + resolvedHostname;
1569
- if (input.AccountId === void 0) {
1570
- throw new Error("Empty value provided for input host prefix: AccountId.");
1571
- }
1572
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1573
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1574
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1575
- }
1576
- }
1577
- b.hn(resolvedHostname);
1578
1313
  b.m("DELETE").h(headers).b(body);
1579
1314
  return b.build();
1580
1315
  }, "se_DeleteBucketTaggingCommand");
@@ -1586,18 +1321,6 @@ var se_DeleteJobTaggingCommand = /* @__PURE__ */ __name(async (input, context) =
1586
1321
  b.bp("/v20180820/jobs/{JobId}/tagging");
1587
1322
  b.p("JobId", () => input.JobId, "{JobId}", false);
1588
1323
  let body;
1589
- let { hostname: resolvedHostname } = await context.endpoint();
1590
- if (context.disableHostPrefix !== true) {
1591
- resolvedHostname = "{AccountId}." + resolvedHostname;
1592
- if (input.AccountId === void 0) {
1593
- throw new Error("Empty value provided for input host prefix: AccountId.");
1594
- }
1595
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1596
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1597
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1598
- }
1599
- }
1600
- b.hn(resolvedHostname);
1601
1324
  b.m("DELETE").h(headers).b(body);
1602
1325
  return b.build();
1603
1326
  }, "se_DeleteJobTaggingCommand");
@@ -1622,18 +1345,6 @@ var se_DeleteMultiRegionAccessPointCommand = /* @__PURE__ */ __name(async (input
1622
1345
  bn.c(se_DeleteMultiRegionAccessPointInput(input[_De], context).n(_De));
1623
1346
  }
1624
1347
  body += bn.toString();
1625
- let { hostname: resolvedHostname } = await context.endpoint();
1626
- if (context.disableHostPrefix !== true) {
1627
- resolvedHostname = "{AccountId}." + resolvedHostname;
1628
- if (input.AccountId === void 0) {
1629
- throw new Error("Empty value provided for input host prefix: AccountId.");
1630
- }
1631
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1632
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1633
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1634
- }
1635
- }
1636
- b.hn(resolvedHostname);
1637
1348
  b.m("POST").h(headers).b(body);
1638
1349
  return b.build();
1639
1350
  }, "se_DeleteMultiRegionAccessPointCommand");
@@ -1644,18 +1355,6 @@ var se_DeletePublicAccessBlockCommand = /* @__PURE__ */ __name(async (input, con
1644
1355
  });
1645
1356
  b.bp("/v20180820/configuration/publicAccessBlock");
1646
1357
  let body;
1647
- let { hostname: resolvedHostname } = await context.endpoint();
1648
- if (context.disableHostPrefix !== true) {
1649
- resolvedHostname = "{AccountId}." + resolvedHostname;
1650
- if (input.AccountId === void 0) {
1651
- throw new Error("Empty value provided for input host prefix: AccountId.");
1652
- }
1653
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1654
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1655
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1656
- }
1657
- }
1658
- b.hn(resolvedHostname);
1659
1358
  b.m("DELETE").h(headers).b(body);
1660
1359
  return b.build();
1661
1360
  }, "se_DeletePublicAccessBlockCommand");
@@ -1667,18 +1366,6 @@ var se_DeleteStorageLensConfigurationCommand = /* @__PURE__ */ __name(async (inp
1667
1366
  b.bp("/v20180820/storagelens/{ConfigId}");
1668
1367
  b.p("ConfigId", () => input.ConfigId, "{ConfigId}", false);
1669
1368
  let body;
1670
- let { hostname: resolvedHostname } = await context.endpoint();
1671
- if (context.disableHostPrefix !== true) {
1672
- resolvedHostname = "{AccountId}." + resolvedHostname;
1673
- if (input.AccountId === void 0) {
1674
- throw new Error("Empty value provided for input host prefix: AccountId.");
1675
- }
1676
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1677
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1678
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1679
- }
1680
- }
1681
- b.hn(resolvedHostname);
1682
1369
  b.m("DELETE").h(headers).b(body);
1683
1370
  return b.build();
1684
1371
  }, "se_DeleteStorageLensConfigurationCommand");
@@ -1690,18 +1377,6 @@ var se_DeleteStorageLensConfigurationTaggingCommand = /* @__PURE__ */ __name(asy
1690
1377
  b.bp("/v20180820/storagelens/{ConfigId}/tagging");
1691
1378
  b.p("ConfigId", () => input.ConfigId, "{ConfigId}", false);
1692
1379
  let body;
1693
- let { hostname: resolvedHostname } = await context.endpoint();
1694
- if (context.disableHostPrefix !== true) {
1695
- resolvedHostname = "{AccountId}." + resolvedHostname;
1696
- if (input.AccountId === void 0) {
1697
- throw new Error("Empty value provided for input host prefix: AccountId.");
1698
- }
1699
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1700
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1701
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1702
- }
1703
- }
1704
- b.hn(resolvedHostname);
1705
1380
  b.m("DELETE").h(headers).b(body);
1706
1381
  return b.build();
1707
1382
  }, "se_DeleteStorageLensConfigurationTaggingCommand");
@@ -1713,18 +1388,6 @@ var se_DeleteStorageLensGroupCommand = /* @__PURE__ */ __name(async (input, cont
1713
1388
  b.bp("/v20180820/storagelensgroup/{Name}");
1714
1389
  b.p("Name", () => input.Name, "{Name}", false);
1715
1390
  let body;
1716
- let { hostname: resolvedHostname } = await context.endpoint();
1717
- if (context.disableHostPrefix !== true) {
1718
- resolvedHostname = "{AccountId}." + resolvedHostname;
1719
- if (input.AccountId === void 0) {
1720
- throw new Error("Empty value provided for input host prefix: AccountId.");
1721
- }
1722
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1723
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1724
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1725
- }
1726
- }
1727
- b.hn(resolvedHostname);
1728
1391
  b.m("DELETE").h(headers).b(body);
1729
1392
  return b.build();
1730
1393
  }, "se_DeleteStorageLensGroupCommand");
@@ -1736,18 +1399,6 @@ var se_DescribeJobCommand = /* @__PURE__ */ __name(async (input, context) => {
1736
1399
  b.bp("/v20180820/jobs/{JobId}");
1737
1400
  b.p("JobId", () => input.JobId, "{JobId}", false);
1738
1401
  let body;
1739
- let { hostname: resolvedHostname } = await context.endpoint();
1740
- if (context.disableHostPrefix !== true) {
1741
- resolvedHostname = "{AccountId}." + resolvedHostname;
1742
- if (input.AccountId === void 0) {
1743
- throw new Error("Empty value provided for input host prefix: AccountId.");
1744
- }
1745
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1746
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1747
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1748
- }
1749
- }
1750
- b.hn(resolvedHostname);
1751
1402
  b.m("GET").h(headers).b(body);
1752
1403
  return b.build();
1753
1404
  }, "se_DescribeJobCommand");
@@ -1759,18 +1410,6 @@ var se_DescribeMultiRegionAccessPointOperationCommand = /* @__PURE__ */ __name(a
1759
1410
  b.bp("/v20180820/async-requests/mrap/{RequestTokenARN+}");
1760
1411
  b.p("RequestTokenARN", () => input.RequestTokenARN, "{RequestTokenARN+}", true);
1761
1412
  let body;
1762
- let { hostname: resolvedHostname } = await context.endpoint();
1763
- if (context.disableHostPrefix !== true) {
1764
- resolvedHostname = "{AccountId}." + resolvedHostname;
1765
- if (input.AccountId === void 0) {
1766
- throw new Error("Empty value provided for input host prefix: AccountId.");
1767
- }
1768
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1769
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1770
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1771
- }
1772
- }
1773
- b.hn(resolvedHostname);
1774
1413
  b.m("GET").h(headers).b(body);
1775
1414
  return b.build();
1776
1415
  }, "se_DescribeMultiRegionAccessPointOperationCommand");
@@ -1781,18 +1420,6 @@ var se_DissociateAccessGrantsIdentityCenterCommand = /* @__PURE__ */ __name(asyn
1781
1420
  });
1782
1421
  b.bp("/v20180820/accessgrantsinstance/identitycenter");
1783
1422
  let body;
1784
- let { hostname: resolvedHostname } = await context.endpoint();
1785
- if (context.disableHostPrefix !== true) {
1786
- resolvedHostname = "{AccountId}." + resolvedHostname;
1787
- if (input.AccountId === void 0) {
1788
- throw new Error("Empty value provided for input host prefix: AccountId.");
1789
- }
1790
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1791
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1792
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1793
- }
1794
- }
1795
- b.hn(resolvedHostname);
1796
1423
  b.m("DELETE").h(headers).b(body);
1797
1424
  return b.build();
1798
1425
  }, "se_DissociateAccessGrantsIdentityCenterCommand");
@@ -1804,18 +1431,6 @@ var se_GetAccessGrantCommand = /* @__PURE__ */ __name(async (input, context) =>
1804
1431
  b.bp("/v20180820/accessgrantsinstance/grant/{AccessGrantId}");
1805
1432
  b.p("AccessGrantId", () => input.AccessGrantId, "{AccessGrantId}", false);
1806
1433
  let body;
1807
- let { hostname: resolvedHostname } = await context.endpoint();
1808
- if (context.disableHostPrefix !== true) {
1809
- resolvedHostname = "{AccountId}." + resolvedHostname;
1810
- if (input.AccountId === void 0) {
1811
- throw new Error("Empty value provided for input host prefix: AccountId.");
1812
- }
1813
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1814
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1815
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1816
- }
1817
- }
1818
- b.hn(resolvedHostname);
1819
1434
  b.m("GET").h(headers).b(body);
1820
1435
  return b.build();
1821
1436
  }, "se_GetAccessGrantCommand");
@@ -1826,18 +1441,6 @@ var se_GetAccessGrantsInstanceCommand = /* @__PURE__ */ __name(async (input, con
1826
1441
  });
1827
1442
  b.bp("/v20180820/accessgrantsinstance");
1828
1443
  let body;
1829
- let { hostname: resolvedHostname } = await context.endpoint();
1830
- if (context.disableHostPrefix !== true) {
1831
- resolvedHostname = "{AccountId}." + resolvedHostname;
1832
- if (input.AccountId === void 0) {
1833
- throw new Error("Empty value provided for input host prefix: AccountId.");
1834
- }
1835
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1836
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1837
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1838
- }
1839
- }
1840
- b.hn(resolvedHostname);
1841
1444
  b.m("GET").h(headers).b(body);
1842
1445
  return b.build();
1843
1446
  }, "se_GetAccessGrantsInstanceCommand");
@@ -1851,18 +1454,6 @@ var se_GetAccessGrantsInstanceForPrefixCommand = /* @__PURE__ */ __name(async (i
1851
1454
  [_s]: [, (0, import_smithy_client.expectNonNull)(input[_SP], `S3Prefix`)]
1852
1455
  });
1853
1456
  let body;
1854
- let { hostname: resolvedHostname } = await context.endpoint();
1855
- if (context.disableHostPrefix !== true) {
1856
- resolvedHostname = "{AccountId}." + resolvedHostname;
1857
- if (input.AccountId === void 0) {
1858
- throw new Error("Empty value provided for input host prefix: AccountId.");
1859
- }
1860
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1861
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1862
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1863
- }
1864
- }
1865
- b.hn(resolvedHostname);
1866
1457
  b.m("GET").h(headers).q(query).b(body);
1867
1458
  return b.build();
1868
1459
  }, "se_GetAccessGrantsInstanceForPrefixCommand");
@@ -1873,18 +1464,6 @@ var se_GetAccessGrantsInstanceResourcePolicyCommand = /* @__PURE__ */ __name(asy
1873
1464
  });
1874
1465
  b.bp("/v20180820/accessgrantsinstance/resourcepolicy");
1875
1466
  let body;
1876
- let { hostname: resolvedHostname } = await context.endpoint();
1877
- if (context.disableHostPrefix !== true) {
1878
- resolvedHostname = "{AccountId}." + resolvedHostname;
1879
- if (input.AccountId === void 0) {
1880
- throw new Error("Empty value provided for input host prefix: AccountId.");
1881
- }
1882
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1883
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1884
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1885
- }
1886
- }
1887
- b.hn(resolvedHostname);
1888
1467
  b.m("GET").h(headers).b(body);
1889
1468
  return b.build();
1890
1469
  }, "se_GetAccessGrantsInstanceResourcePolicyCommand");
@@ -1896,18 +1475,6 @@ var se_GetAccessGrantsLocationCommand = /* @__PURE__ */ __name(async (input, con
1896
1475
  b.bp("/v20180820/accessgrantsinstance/location/{AccessGrantsLocationId}");
1897
1476
  b.p("AccessGrantsLocationId", () => input.AccessGrantsLocationId, "{AccessGrantsLocationId}", false);
1898
1477
  let body;
1899
- let { hostname: resolvedHostname } = await context.endpoint();
1900
- if (context.disableHostPrefix !== true) {
1901
- resolvedHostname = "{AccountId}." + resolvedHostname;
1902
- if (input.AccountId === void 0) {
1903
- throw new Error("Empty value provided for input host prefix: AccountId.");
1904
- }
1905
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1906
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1907
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1908
- }
1909
- }
1910
- b.hn(resolvedHostname);
1911
1478
  b.m("GET").h(headers).b(body);
1912
1479
  return b.build();
1913
1480
  }, "se_GetAccessGrantsLocationCommand");
@@ -1919,18 +1486,6 @@ var se_GetAccessPointCommand = /* @__PURE__ */ __name(async (input, context) =>
1919
1486
  b.bp("/v20180820/accesspoint/{Name}");
1920
1487
  b.p("Name", () => input.Name, "{Name}", false);
1921
1488
  let body;
1922
- let { hostname: resolvedHostname } = await context.endpoint();
1923
- if (context.disableHostPrefix !== true) {
1924
- resolvedHostname = "{AccountId}." + resolvedHostname;
1925
- if (input.AccountId === void 0) {
1926
- throw new Error("Empty value provided for input host prefix: AccountId.");
1927
- }
1928
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1929
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1930
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1931
- }
1932
- }
1933
- b.hn(resolvedHostname);
1934
1489
  b.m("GET").h(headers).b(body);
1935
1490
  return b.build();
1936
1491
  }, "se_GetAccessPointCommand");
@@ -1942,18 +1497,6 @@ var se_GetAccessPointConfigurationForObjectLambdaCommand = /* @__PURE__ */ __nam
1942
1497
  b.bp("/v20180820/accesspointforobjectlambda/{Name}/configuration");
1943
1498
  b.p("Name", () => input.Name, "{Name}", false);
1944
1499
  let body;
1945
- let { hostname: resolvedHostname } = await context.endpoint();
1946
- if (context.disableHostPrefix !== true) {
1947
- resolvedHostname = "{AccountId}." + resolvedHostname;
1948
- if (input.AccountId === void 0) {
1949
- throw new Error("Empty value provided for input host prefix: AccountId.");
1950
- }
1951
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1952
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1953
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1954
- }
1955
- }
1956
- b.hn(resolvedHostname);
1957
1500
  b.m("GET").h(headers).b(body);
1958
1501
  return b.build();
1959
1502
  }, "se_GetAccessPointConfigurationForObjectLambdaCommand");
@@ -1965,18 +1508,6 @@ var se_GetAccessPointForObjectLambdaCommand = /* @__PURE__ */ __name(async (inpu
1965
1508
  b.bp("/v20180820/accesspointforobjectlambda/{Name}");
1966
1509
  b.p("Name", () => input.Name, "{Name}", false);
1967
1510
  let body;
1968
- let { hostname: resolvedHostname } = await context.endpoint();
1969
- if (context.disableHostPrefix !== true) {
1970
- resolvedHostname = "{AccountId}." + resolvedHostname;
1971
- if (input.AccountId === void 0) {
1972
- throw new Error("Empty value provided for input host prefix: AccountId.");
1973
- }
1974
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1975
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1976
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1977
- }
1978
- }
1979
- b.hn(resolvedHostname);
1980
1511
  b.m("GET").h(headers).b(body);
1981
1512
  return b.build();
1982
1513
  }, "se_GetAccessPointForObjectLambdaCommand");
@@ -1988,18 +1519,6 @@ var se_GetAccessPointPolicyCommand = /* @__PURE__ */ __name(async (input, contex
1988
1519
  b.bp("/v20180820/accesspoint/{Name}/policy");
1989
1520
  b.p("Name", () => input.Name, "{Name}", false);
1990
1521
  let body;
1991
- let { hostname: resolvedHostname } = await context.endpoint();
1992
- if (context.disableHostPrefix !== true) {
1993
- resolvedHostname = "{AccountId}." + resolvedHostname;
1994
- if (input.AccountId === void 0) {
1995
- throw new Error("Empty value provided for input host prefix: AccountId.");
1996
- }
1997
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1998
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
1999
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2000
- }
2001
- }
2002
- b.hn(resolvedHostname);
2003
1522
  b.m("GET").h(headers).b(body);
2004
1523
  return b.build();
2005
1524
  }, "se_GetAccessPointPolicyCommand");
@@ -2011,18 +1530,6 @@ var se_GetAccessPointPolicyForObjectLambdaCommand = /* @__PURE__ */ __name(async
2011
1530
  b.bp("/v20180820/accesspointforobjectlambda/{Name}/policy");
2012
1531
  b.p("Name", () => input.Name, "{Name}", false);
2013
1532
  let body;
2014
- let { hostname: resolvedHostname } = await context.endpoint();
2015
- if (context.disableHostPrefix !== true) {
2016
- resolvedHostname = "{AccountId}." + resolvedHostname;
2017
- if (input.AccountId === void 0) {
2018
- throw new Error("Empty value provided for input host prefix: AccountId.");
2019
- }
2020
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2021
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2022
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2023
- }
2024
- }
2025
- b.hn(resolvedHostname);
2026
1533
  b.m("GET").h(headers).b(body);
2027
1534
  return b.build();
2028
1535
  }, "se_GetAccessPointPolicyForObjectLambdaCommand");
@@ -2034,18 +1541,6 @@ var se_GetAccessPointPolicyStatusCommand = /* @__PURE__ */ __name(async (input,
2034
1541
  b.bp("/v20180820/accesspoint/{Name}/policyStatus");
2035
1542
  b.p("Name", () => input.Name, "{Name}", false);
2036
1543
  let body;
2037
- let { hostname: resolvedHostname } = await context.endpoint();
2038
- if (context.disableHostPrefix !== true) {
2039
- resolvedHostname = "{AccountId}." + resolvedHostname;
2040
- if (input.AccountId === void 0) {
2041
- throw new Error("Empty value provided for input host prefix: AccountId.");
2042
- }
2043
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2044
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2045
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2046
- }
2047
- }
2048
- b.hn(resolvedHostname);
2049
1544
  b.m("GET").h(headers).b(body);
2050
1545
  return b.build();
2051
1546
  }, "se_GetAccessPointPolicyStatusCommand");
@@ -2057,18 +1552,6 @@ var se_GetAccessPointPolicyStatusForObjectLambdaCommand = /* @__PURE__ */ __name
2057
1552
  b.bp("/v20180820/accesspointforobjectlambda/{Name}/policyStatus");
2058
1553
  b.p("Name", () => input.Name, "{Name}", false);
2059
1554
  let body;
2060
- let { hostname: resolvedHostname } = await context.endpoint();
2061
- if (context.disableHostPrefix !== true) {
2062
- resolvedHostname = "{AccountId}." + resolvedHostname;
2063
- if (input.AccountId === void 0) {
2064
- throw new Error("Empty value provided for input host prefix: AccountId.");
2065
- }
2066
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2067
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2068
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2069
- }
2070
- }
2071
- b.hn(resolvedHostname);
2072
1555
  b.m("GET").h(headers).b(body);
2073
1556
  return b.build();
2074
1557
  }, "se_GetAccessPointPolicyStatusForObjectLambdaCommand");
@@ -2091,18 +1574,6 @@ var se_GetBucketCommand = /* @__PURE__ */ __name(async (input, context) => {
2091
1574
  b.bp("/v20180820/bucket/{Bucket}");
2092
1575
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
2093
1576
  let body;
2094
- let { hostname: resolvedHostname } = await context.endpoint();
2095
- if (context.disableHostPrefix !== true) {
2096
- resolvedHostname = "{AccountId}." + resolvedHostname;
2097
- if (input.AccountId === void 0) {
2098
- throw new Error("Empty value provided for input host prefix: AccountId.");
2099
- }
2100
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2101
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2102
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2103
- }
2104
- }
2105
- b.hn(resolvedHostname);
2106
1577
  b.m("GET").h(headers).b(body);
2107
1578
  return b.build();
2108
1579
  }, "se_GetBucketCommand");
@@ -2114,18 +1585,6 @@ var se_GetBucketLifecycleConfigurationCommand = /* @__PURE__ */ __name(async (in
2114
1585
  b.bp("/v20180820/bucket/{Bucket}/lifecycleconfiguration");
2115
1586
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
2116
1587
  let body;
2117
- let { hostname: resolvedHostname } = await context.endpoint();
2118
- if (context.disableHostPrefix !== true) {
2119
- resolvedHostname = "{AccountId}." + resolvedHostname;
2120
- if (input.AccountId === void 0) {
2121
- throw new Error("Empty value provided for input host prefix: AccountId.");
2122
- }
2123
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2124
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2125
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2126
- }
2127
- }
2128
- b.hn(resolvedHostname);
2129
1588
  b.m("GET").h(headers).b(body);
2130
1589
  return b.build();
2131
1590
  }, "se_GetBucketLifecycleConfigurationCommand");
@@ -2137,18 +1596,6 @@ var se_GetBucketPolicyCommand = /* @__PURE__ */ __name(async (input, context) =>
2137
1596
  b.bp("/v20180820/bucket/{Bucket}/policy");
2138
1597
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
2139
1598
  let body;
2140
- let { hostname: resolvedHostname } = await context.endpoint();
2141
- if (context.disableHostPrefix !== true) {
2142
- resolvedHostname = "{AccountId}." + resolvedHostname;
2143
- if (input.AccountId === void 0) {
2144
- throw new Error("Empty value provided for input host prefix: AccountId.");
2145
- }
2146
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2147
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2148
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2149
- }
2150
- }
2151
- b.hn(resolvedHostname);
2152
1599
  b.m("GET").h(headers).b(body);
2153
1600
  return b.build();
2154
1601
  }, "se_GetBucketPolicyCommand");
@@ -2160,18 +1607,6 @@ var se_GetBucketReplicationCommand = /* @__PURE__ */ __name(async (input, contex
2160
1607
  b.bp("/v20180820/bucket/{Bucket}/replication");
2161
1608
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
2162
1609
  let body;
2163
- let { hostname: resolvedHostname } = await context.endpoint();
2164
- if (context.disableHostPrefix !== true) {
2165
- resolvedHostname = "{AccountId}." + resolvedHostname;
2166
- if (input.AccountId === void 0) {
2167
- throw new Error("Empty value provided for input host prefix: AccountId.");
2168
- }
2169
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2170
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2171
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2172
- }
2173
- }
2174
- b.hn(resolvedHostname);
2175
1610
  b.m("GET").h(headers).b(body);
2176
1611
  return b.build();
2177
1612
  }, "se_GetBucketReplicationCommand");
@@ -2183,18 +1618,6 @@ var se_GetBucketTaggingCommand = /* @__PURE__ */ __name(async (input, context) =
2183
1618
  b.bp("/v20180820/bucket/{Bucket}/tagging");
2184
1619
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
2185
1620
  let body;
2186
- let { hostname: resolvedHostname } = await context.endpoint();
2187
- if (context.disableHostPrefix !== true) {
2188
- resolvedHostname = "{AccountId}." + resolvedHostname;
2189
- if (input.AccountId === void 0) {
2190
- throw new Error("Empty value provided for input host prefix: AccountId.");
2191
- }
2192
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2193
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2194
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2195
- }
2196
- }
2197
- b.hn(resolvedHostname);
2198
1621
  b.m("GET").h(headers).b(body);
2199
1622
  return b.build();
2200
1623
  }, "se_GetBucketTaggingCommand");
@@ -2206,18 +1629,6 @@ var se_GetBucketVersioningCommand = /* @__PURE__ */ __name(async (input, context
2206
1629
  b.bp("/v20180820/bucket/{Bucket}/versioning");
2207
1630
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
2208
1631
  let body;
2209
- let { hostname: resolvedHostname } = await context.endpoint();
2210
- if (context.disableHostPrefix !== true) {
2211
- resolvedHostname = "{AccountId}." + resolvedHostname;
2212
- if (input.AccountId === void 0) {
2213
- throw new Error("Empty value provided for input host prefix: AccountId.");
2214
- }
2215
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2216
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2217
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2218
- }
2219
- }
2220
- b.hn(resolvedHostname);
2221
1632
  b.m("GET").h(headers).b(body);
2222
1633
  return b.build();
2223
1634
  }, "se_GetBucketVersioningCommand");
@@ -2235,18 +1646,6 @@ var se_GetDataAccessCommand = /* @__PURE__ */ __name(async (input, context) => {
2235
1646
  [_tT]: [, input[_TT]]
2236
1647
  });
2237
1648
  let body;
2238
- let { hostname: resolvedHostname } = await context.endpoint();
2239
- if (context.disableHostPrefix !== true) {
2240
- resolvedHostname = "{AccountId}." + resolvedHostname;
2241
- if (input.AccountId === void 0) {
2242
- throw new Error("Empty value provided for input host prefix: AccountId.");
2243
- }
2244
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2245
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2246
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2247
- }
2248
- }
2249
- b.hn(resolvedHostname);
2250
1649
  b.m("GET").h(headers).q(query).b(body);
2251
1650
  return b.build();
2252
1651
  }, "se_GetDataAccessCommand");
@@ -2258,18 +1657,6 @@ var se_GetJobTaggingCommand = /* @__PURE__ */ __name(async (input, context) => {
2258
1657
  b.bp("/v20180820/jobs/{JobId}/tagging");
2259
1658
  b.p("JobId", () => input.JobId, "{JobId}", false);
2260
1659
  let body;
2261
- let { hostname: resolvedHostname } = await context.endpoint();
2262
- if (context.disableHostPrefix !== true) {
2263
- resolvedHostname = "{AccountId}." + resolvedHostname;
2264
- if (input.AccountId === void 0) {
2265
- throw new Error("Empty value provided for input host prefix: AccountId.");
2266
- }
2267
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2268
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2269
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2270
- }
2271
- }
2272
- b.hn(resolvedHostname);
2273
1660
  b.m("GET").h(headers).b(body);
2274
1661
  return b.build();
2275
1662
  }, "se_GetJobTaggingCommand");
@@ -2281,18 +1668,6 @@ var se_GetMultiRegionAccessPointCommand = /* @__PURE__ */ __name(async (input, c
2281
1668
  b.bp("/v20180820/mrap/instances/{Name+}");
2282
1669
  b.p("Name", () => input.Name, "{Name+}", true);
2283
1670
  let body;
2284
- let { hostname: resolvedHostname } = await context.endpoint();
2285
- if (context.disableHostPrefix !== true) {
2286
- resolvedHostname = "{AccountId}." + resolvedHostname;
2287
- if (input.AccountId === void 0) {
2288
- throw new Error("Empty value provided for input host prefix: AccountId.");
2289
- }
2290
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2291
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2292
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2293
- }
2294
- }
2295
- b.hn(resolvedHostname);
2296
1671
  b.m("GET").h(headers).b(body);
2297
1672
  return b.build();
2298
1673
  }, "se_GetMultiRegionAccessPointCommand");
@@ -2304,18 +1679,6 @@ var se_GetMultiRegionAccessPointPolicyCommand = /* @__PURE__ */ __name(async (in
2304
1679
  b.bp("/v20180820/mrap/instances/{Name+}/policy");
2305
1680
  b.p("Name", () => input.Name, "{Name+}", true);
2306
1681
  let body;
2307
- let { hostname: resolvedHostname } = await context.endpoint();
2308
- if (context.disableHostPrefix !== true) {
2309
- resolvedHostname = "{AccountId}." + resolvedHostname;
2310
- if (input.AccountId === void 0) {
2311
- throw new Error("Empty value provided for input host prefix: AccountId.");
2312
- }
2313
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2314
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2315
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2316
- }
2317
- }
2318
- b.hn(resolvedHostname);
2319
1682
  b.m("GET").h(headers).b(body);
2320
1683
  return b.build();
2321
1684
  }, "se_GetMultiRegionAccessPointPolicyCommand");
@@ -2327,18 +1690,6 @@ var se_GetMultiRegionAccessPointPolicyStatusCommand = /* @__PURE__ */ __name(asy
2327
1690
  b.bp("/v20180820/mrap/instances/{Name+}/policystatus");
2328
1691
  b.p("Name", () => input.Name, "{Name+}", true);
2329
1692
  let body;
2330
- let { hostname: resolvedHostname } = await context.endpoint();
2331
- if (context.disableHostPrefix !== true) {
2332
- resolvedHostname = "{AccountId}." + resolvedHostname;
2333
- if (input.AccountId === void 0) {
2334
- throw new Error("Empty value provided for input host prefix: AccountId.");
2335
- }
2336
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2337
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2338
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2339
- }
2340
- }
2341
- b.hn(resolvedHostname);
2342
1693
  b.m("GET").h(headers).b(body);
2343
1694
  return b.build();
2344
1695
  }, "se_GetMultiRegionAccessPointPolicyStatusCommand");
@@ -2350,18 +1701,6 @@ var se_GetMultiRegionAccessPointRoutesCommand = /* @__PURE__ */ __name(async (in
2350
1701
  b.bp("/v20180820/mrap/instances/{Mrap+}/routes");
2351
1702
  b.p("Mrap", () => input.Mrap, "{Mrap+}", true);
2352
1703
  let body;
2353
- let { hostname: resolvedHostname } = await context.endpoint();
2354
- if (context.disableHostPrefix !== true) {
2355
- resolvedHostname = "{AccountId}." + resolvedHostname;
2356
- if (input.AccountId === void 0) {
2357
- throw new Error("Empty value provided for input host prefix: AccountId.");
2358
- }
2359
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2360
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2361
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2362
- }
2363
- }
2364
- b.hn(resolvedHostname);
2365
1704
  b.m("GET").h(headers).b(body);
2366
1705
  return b.build();
2367
1706
  }, "se_GetMultiRegionAccessPointRoutesCommand");
@@ -2372,18 +1711,6 @@ var se_GetPublicAccessBlockCommand = /* @__PURE__ */ __name(async (input, contex
2372
1711
  });
2373
1712
  b.bp("/v20180820/configuration/publicAccessBlock");
2374
1713
  let body;
2375
- let { hostname: resolvedHostname } = await context.endpoint();
2376
- if (context.disableHostPrefix !== true) {
2377
- resolvedHostname = "{AccountId}." + resolvedHostname;
2378
- if (input.AccountId === void 0) {
2379
- throw new Error("Empty value provided for input host prefix: AccountId.");
2380
- }
2381
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2382
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2383
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2384
- }
2385
- }
2386
- b.hn(resolvedHostname);
2387
1714
  b.m("GET").h(headers).b(body);
2388
1715
  return b.build();
2389
1716
  }, "se_GetPublicAccessBlockCommand");
@@ -2395,18 +1722,6 @@ var se_GetStorageLensConfigurationCommand = /* @__PURE__ */ __name(async (input,
2395
1722
  b.bp("/v20180820/storagelens/{ConfigId}");
2396
1723
  b.p("ConfigId", () => input.ConfigId, "{ConfigId}", false);
2397
1724
  let body;
2398
- let { hostname: resolvedHostname } = await context.endpoint();
2399
- if (context.disableHostPrefix !== true) {
2400
- resolvedHostname = "{AccountId}." + resolvedHostname;
2401
- if (input.AccountId === void 0) {
2402
- throw new Error("Empty value provided for input host prefix: AccountId.");
2403
- }
2404
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2405
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2406
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2407
- }
2408
- }
2409
- b.hn(resolvedHostname);
2410
1725
  b.m("GET").h(headers).b(body);
2411
1726
  return b.build();
2412
1727
  }, "se_GetStorageLensConfigurationCommand");
@@ -2418,18 +1733,6 @@ var se_GetStorageLensConfigurationTaggingCommand = /* @__PURE__ */ __name(async
2418
1733
  b.bp("/v20180820/storagelens/{ConfigId}/tagging");
2419
1734
  b.p("ConfigId", () => input.ConfigId, "{ConfigId}", false);
2420
1735
  let body;
2421
- let { hostname: resolvedHostname } = await context.endpoint();
2422
- if (context.disableHostPrefix !== true) {
2423
- resolvedHostname = "{AccountId}." + resolvedHostname;
2424
- if (input.AccountId === void 0) {
2425
- throw new Error("Empty value provided for input host prefix: AccountId.");
2426
- }
2427
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2428
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2429
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2430
- }
2431
- }
2432
- b.hn(resolvedHostname);
2433
1736
  b.m("GET").h(headers).b(body);
2434
1737
  return b.build();
2435
1738
  }, "se_GetStorageLensConfigurationTaggingCommand");
@@ -2441,18 +1744,6 @@ var se_GetStorageLensGroupCommand = /* @__PURE__ */ __name(async (input, context
2441
1744
  b.bp("/v20180820/storagelensgroup/{Name}");
2442
1745
  b.p("Name", () => input.Name, "{Name}", false);
2443
1746
  let body;
2444
- let { hostname: resolvedHostname } = await context.endpoint();
2445
- if (context.disableHostPrefix !== true) {
2446
- resolvedHostname = "{AccountId}." + resolvedHostname;
2447
- if (input.AccountId === void 0) {
2448
- throw new Error("Empty value provided for input host prefix: AccountId.");
2449
- }
2450
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2451
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2452
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2453
- }
2454
- }
2455
- b.hn(resolvedHostname);
2456
1747
  b.m("GET").h(headers).b(body);
2457
1748
  return b.build();
2458
1749
  }, "se_GetStorageLensGroupCommand");
@@ -2472,18 +1763,6 @@ var se_ListAccessGrantsCommand = /* @__PURE__ */ __name(async (input, context) =
2472
1763
  [_aa]: [, input[_AA]]
2473
1764
  });
2474
1765
  let body;
2475
- let { hostname: resolvedHostname } = await context.endpoint();
2476
- if (context.disableHostPrefix !== true) {
2477
- resolvedHostname = "{AccountId}." + resolvedHostname;
2478
- if (input.AccountId === void 0) {
2479
- throw new Error("Empty value provided for input host prefix: AccountId.");
2480
- }
2481
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2482
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2483
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2484
- }
2485
- }
2486
- b.hn(resolvedHostname);
2487
1766
  b.m("GET").h(headers).q(query).b(body);
2488
1767
  return b.build();
2489
1768
  }, "se_ListAccessGrantsCommand");
@@ -2498,18 +1777,6 @@ var se_ListAccessGrantsInstancesCommand = /* @__PURE__ */ __name(async (input, c
2498
1777
  [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()]
2499
1778
  });
2500
1779
  let body;
2501
- let { hostname: resolvedHostname } = await context.endpoint();
2502
- if (context.disableHostPrefix !== true) {
2503
- resolvedHostname = "{AccountId}." + resolvedHostname;
2504
- if (input.AccountId === void 0) {
2505
- throw new Error("Empty value provided for input host prefix: AccountId.");
2506
- }
2507
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2508
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2509
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2510
- }
2511
- }
2512
- b.hn(resolvedHostname);
2513
1780
  b.m("GET").h(headers).q(query).b(body);
2514
1781
  return b.build();
2515
1782
  }, "se_ListAccessGrantsInstancesCommand");
@@ -2525,18 +1792,6 @@ var se_ListAccessGrantsLocationsCommand = /* @__PURE__ */ __name(async (input, c
2525
1792
  [_l]: [, input[_LS]]
2526
1793
  });
2527
1794
  let body;
2528
- let { hostname: resolvedHostname } = await context.endpoint();
2529
- if (context.disableHostPrefix !== true) {
2530
- resolvedHostname = "{AccountId}." + resolvedHostname;
2531
- if (input.AccountId === void 0) {
2532
- throw new Error("Empty value provided for input host prefix: AccountId.");
2533
- }
2534
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2535
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2536
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2537
- }
2538
- }
2539
- b.hn(resolvedHostname);
2540
1795
  b.m("GET").h(headers).q(query).b(body);
2541
1796
  return b.build();
2542
1797
  }, "se_ListAccessGrantsLocationsCommand");
@@ -2552,18 +1807,6 @@ var se_ListAccessPointsCommand = /* @__PURE__ */ __name(async (input, context) =
2552
1807
  [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()]
2553
1808
  });
2554
1809
  let body;
2555
- let { hostname: resolvedHostname } = await context.endpoint();
2556
- if (context.disableHostPrefix !== true) {
2557
- resolvedHostname = "{AccountId}." + resolvedHostname;
2558
- if (input.AccountId === void 0) {
2559
- throw new Error("Empty value provided for input host prefix: AccountId.");
2560
- }
2561
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2562
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2563
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2564
- }
2565
- }
2566
- b.hn(resolvedHostname);
2567
1810
  b.m("GET").h(headers).q(query).b(body);
2568
1811
  return b.build();
2569
1812
  }, "se_ListAccessPointsCommand");
@@ -2593,18 +1836,6 @@ var se_ListAccessPointsForObjectLambdaCommand = /* @__PURE__ */ __name(async (in
2593
1836
  [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()]
2594
1837
  });
2595
1838
  let body;
2596
- let { hostname: resolvedHostname } = await context.endpoint();
2597
- if (context.disableHostPrefix !== true) {
2598
- resolvedHostname = "{AccountId}." + resolvedHostname;
2599
- if (input.AccountId === void 0) {
2600
- throw new Error("Empty value provided for input host prefix: AccountId.");
2601
- }
2602
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2603
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2604
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2605
- }
2606
- }
2607
- b.hn(resolvedHostname);
2608
1839
  b.m("GET").h(headers).q(query).b(body);
2609
1840
  return b.build();
2610
1841
  }, "se_ListAccessPointsForObjectLambdaCommand");
@@ -2621,18 +1852,6 @@ var se_ListCallerAccessGrantsCommand = /* @__PURE__ */ __name(async (input, cont
2621
1852
  [_aBA]: [() => input.AllowedByApplication !== void 0, () => input[_ABA].toString()]
2622
1853
  });
2623
1854
  let body;
2624
- let { hostname: resolvedHostname } = await context.endpoint();
2625
- if (context.disableHostPrefix !== true) {
2626
- resolvedHostname = "{AccountId}." + resolvedHostname;
2627
- if (input.AccountId === void 0) {
2628
- throw new Error("Empty value provided for input host prefix: AccountId.");
2629
- }
2630
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2631
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2632
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2633
- }
2634
- }
2635
- b.hn(resolvedHostname);
2636
1855
  b.m("GET").h(headers).q(query).b(body);
2637
1856
  return b.build();
2638
1857
  }, "se_ListCallerAccessGrantsCommand");
@@ -2648,18 +1867,6 @@ var se_ListJobsCommand = /* @__PURE__ */ __name(async (input, context) => {
2648
1867
  [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()]
2649
1868
  });
2650
1869
  let body;
2651
- let { hostname: resolvedHostname } = await context.endpoint();
2652
- if (context.disableHostPrefix !== true) {
2653
- resolvedHostname = "{AccountId}." + resolvedHostname;
2654
- if (input.AccountId === void 0) {
2655
- throw new Error("Empty value provided for input host prefix: AccountId.");
2656
- }
2657
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2658
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2659
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2660
- }
2661
- }
2662
- b.hn(resolvedHostname);
2663
1870
  b.m("GET").h(headers).q(query).b(body);
2664
1871
  return b.build();
2665
1872
  }, "se_ListJobsCommand");
@@ -2674,18 +1881,6 @@ var se_ListMultiRegionAccessPointsCommand = /* @__PURE__ */ __name(async (input,
2674
1881
  [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()]
2675
1882
  });
2676
1883
  let body;
2677
- let { hostname: resolvedHostname } = await context.endpoint();
2678
- if (context.disableHostPrefix !== true) {
2679
- resolvedHostname = "{AccountId}." + resolvedHostname;
2680
- if (input.AccountId === void 0) {
2681
- throw new Error("Empty value provided for input host prefix: AccountId.");
2682
- }
2683
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2684
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2685
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2686
- }
2687
- }
2688
- b.hn(resolvedHostname);
2689
1884
  b.m("GET").h(headers).q(query).b(body);
2690
1885
  return b.build();
2691
1886
  }, "se_ListMultiRegionAccessPointsCommand");
@@ -2701,18 +1896,6 @@ var se_ListRegionalBucketsCommand = /* @__PURE__ */ __name(async (input, context
2701
1896
  [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()]
2702
1897
  });
2703
1898
  let body;
2704
- let { hostname: resolvedHostname } = await context.endpoint();
2705
- if (context.disableHostPrefix !== true) {
2706
- resolvedHostname = "{AccountId}." + resolvedHostname;
2707
- if (input.AccountId === void 0) {
2708
- throw new Error("Empty value provided for input host prefix: AccountId.");
2709
- }
2710
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2711
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2712
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2713
- }
2714
- }
2715
- b.hn(resolvedHostname);
2716
1899
  b.m("GET").h(headers).q(query).b(body);
2717
1900
  return b.build();
2718
1901
  }, "se_ListRegionalBucketsCommand");
@@ -2726,18 +1909,6 @@ var se_ListStorageLensConfigurationsCommand = /* @__PURE__ */ __name(async (inpu
2726
1909
  [_nT]: [, input[_NT]]
2727
1910
  });
2728
1911
  let body;
2729
- let { hostname: resolvedHostname } = await context.endpoint();
2730
- if (context.disableHostPrefix !== true) {
2731
- resolvedHostname = "{AccountId}." + resolvedHostname;
2732
- if (input.AccountId === void 0) {
2733
- throw new Error("Empty value provided for input host prefix: AccountId.");
2734
- }
2735
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2736
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2737
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2738
- }
2739
- }
2740
- b.hn(resolvedHostname);
2741
1912
  b.m("GET").h(headers).q(query).b(body);
2742
1913
  return b.build();
2743
1914
  }, "se_ListStorageLensConfigurationsCommand");
@@ -2751,18 +1922,6 @@ var se_ListStorageLensGroupsCommand = /* @__PURE__ */ __name(async (input, conte
2751
1922
  [_nT]: [, input[_NT]]
2752
1923
  });
2753
1924
  let body;
2754
- let { hostname: resolvedHostname } = await context.endpoint();
2755
- if (context.disableHostPrefix !== true) {
2756
- resolvedHostname = "{AccountId}." + resolvedHostname;
2757
- if (input.AccountId === void 0) {
2758
- throw new Error("Empty value provided for input host prefix: AccountId.");
2759
- }
2760
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2761
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2762
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2763
- }
2764
- }
2765
- b.hn(resolvedHostname);
2766
1925
  b.m("GET").h(headers).q(query).b(body);
2767
1926
  return b.build();
2768
1927
  }, "se_ListStorageLensGroupsCommand");
@@ -2774,18 +1933,6 @@ var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context
2774
1933
  b.bp("/v20180820/tags/{ResourceArn+}");
2775
1934
  b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn+}", true);
2776
1935
  let body;
2777
- let { hostname: resolvedHostname } = await context.endpoint();
2778
- if (context.disableHostPrefix !== true) {
2779
- resolvedHostname = "{AccountId}." + resolvedHostname;
2780
- if (input.AccountId === void 0) {
2781
- throw new Error("Empty value provided for input host prefix: AccountId.");
2782
- }
2783
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2784
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2785
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2786
- }
2787
- }
2788
- b.hn(resolvedHostname);
2789
1936
  b.m("GET").h(headers).b(body);
2790
1937
  return b.build();
2791
1938
  }, "se_ListTagsForResourceCommand");
@@ -2805,18 +1952,6 @@ var se_PutAccessGrantsInstanceResourcePolicyCommand = /* @__PURE__ */ __name(asy
2805
1952
  bn.c(import_xml_builder.XmlNode.of(_PD, input[_Po]).n(_Po));
2806
1953
  }
2807
1954
  body += bn.toString();
2808
- let { hostname: resolvedHostname } = await context.endpoint();
2809
- if (context.disableHostPrefix !== true) {
2810
- resolvedHostname = "{AccountId}." + resolvedHostname;
2811
- if (input.AccountId === void 0) {
2812
- throw new Error("Empty value provided for input host prefix: AccountId.");
2813
- }
2814
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2815
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2816
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2817
- }
2818
- }
2819
- b.hn(resolvedHostname);
2820
1955
  b.m("PUT").h(headers).b(body);
2821
1956
  return b.build();
2822
1957
  }, "se_PutAccessGrantsInstanceResourcePolicyCommand");
@@ -2836,18 +1971,6 @@ var se_PutAccessPointConfigurationForObjectLambdaCommand = /* @__PURE__ */ __nam
2836
1971
  bn.c(se_ObjectLambdaConfiguration(input[_C], context).n(_C));
2837
1972
  }
2838
1973
  body += bn.toString();
2839
- let { hostname: resolvedHostname } = await context.endpoint();
2840
- if (context.disableHostPrefix !== true) {
2841
- resolvedHostname = "{AccountId}." + resolvedHostname;
2842
- if (input.AccountId === void 0) {
2843
- throw new Error("Empty value provided for input host prefix: AccountId.");
2844
- }
2845
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2846
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2847
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2848
- }
2849
- }
2850
- b.hn(resolvedHostname);
2851
1974
  b.m("PUT").h(headers).b(body);
2852
1975
  return b.build();
2853
1976
  }, "se_PutAccessPointConfigurationForObjectLambdaCommand");
@@ -2865,18 +1988,6 @@ var se_PutAccessPointPolicyCommand = /* @__PURE__ */ __name(async (input, contex
2865
1988
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
2866
1989
  bn.cc(input, _Po);
2867
1990
  body += bn.toString();
2868
- let { hostname: resolvedHostname } = await context.endpoint();
2869
- if (context.disableHostPrefix !== true) {
2870
- resolvedHostname = "{AccountId}." + resolvedHostname;
2871
- if (input.AccountId === void 0) {
2872
- throw new Error("Empty value provided for input host prefix: AccountId.");
2873
- }
2874
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2875
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2876
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2877
- }
2878
- }
2879
- b.hn(resolvedHostname);
2880
1991
  b.m("PUT").h(headers).b(body);
2881
1992
  return b.build();
2882
1993
  }, "se_PutAccessPointPolicyCommand");
@@ -2896,18 +2007,6 @@ var se_PutAccessPointPolicyForObjectLambdaCommand = /* @__PURE__ */ __name(async
2896
2007
  bn.c(import_xml_builder.XmlNode.of(_OLP, input[_Po]).n(_Po));
2897
2008
  }
2898
2009
  body += bn.toString();
2899
- let { hostname: resolvedHostname } = await context.endpoint();
2900
- if (context.disableHostPrefix !== true) {
2901
- resolvedHostname = "{AccountId}." + resolvedHostname;
2902
- if (input.AccountId === void 0) {
2903
- throw new Error("Empty value provided for input host prefix: AccountId.");
2904
- }
2905
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2906
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2907
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2908
- }
2909
- }
2910
- b.hn(resolvedHostname);
2911
2010
  b.m("PUT").h(headers).b(body);
2912
2011
  return b.build();
2913
2012
  }, "se_PutAccessPointPolicyForObjectLambdaCommand");
@@ -2946,18 +2045,6 @@ var se_PutBucketLifecycleConfigurationCommand = /* @__PURE__ */ __name(async (in
2946
2045
  contents.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
2947
2046
  body += contents.toString();
2948
2047
  }
2949
- let { hostname: resolvedHostname } = await context.endpoint();
2950
- if (context.disableHostPrefix !== true) {
2951
- resolvedHostname = "{AccountId}." + resolvedHostname;
2952
- if (input.AccountId === void 0) {
2953
- throw new Error("Empty value provided for input host prefix: AccountId.");
2954
- }
2955
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2956
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2957
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2958
- }
2959
- }
2960
- b.hn(resolvedHostname);
2961
2048
  b.m("PUT").h(headers).b(body);
2962
2049
  return b.build();
2963
2050
  }, "se_PutBucketLifecycleConfigurationCommand");
@@ -2976,18 +2063,6 @@ var se_PutBucketPolicyCommand = /* @__PURE__ */ __name(async (input, context) =>
2976
2063
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
2977
2064
  bn.cc(input, _Po);
2978
2065
  body += bn.toString();
2979
- let { hostname: resolvedHostname } = await context.endpoint();
2980
- if (context.disableHostPrefix !== true) {
2981
- resolvedHostname = "{AccountId}." + resolvedHostname;
2982
- if (input.AccountId === void 0) {
2983
- throw new Error("Empty value provided for input host prefix: AccountId.");
2984
- }
2985
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2986
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
2987
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2988
- }
2989
- }
2990
- b.hn(resolvedHostname);
2991
2066
  b.m("PUT").h(headers).b(body);
2992
2067
  return b.build();
2993
2068
  }, "se_PutBucketPolicyCommand");
@@ -3007,18 +2082,6 @@ var se_PutBucketReplicationCommand = /* @__PURE__ */ __name(async (input, contex
3007
2082
  contents.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
3008
2083
  body += contents.toString();
3009
2084
  }
3010
- let { hostname: resolvedHostname } = await context.endpoint();
3011
- if (context.disableHostPrefix !== true) {
3012
- resolvedHostname = "{AccountId}." + resolvedHostname;
3013
- if (input.AccountId === void 0) {
3014
- throw new Error("Empty value provided for input host prefix: AccountId.");
3015
- }
3016
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
3017
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
3018
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
3019
- }
3020
- }
3021
- b.hn(resolvedHostname);
3022
2085
  b.m("PUT").h(headers).b(body);
3023
2086
  return b.build();
3024
2087
  }, "se_PutBucketReplicationCommand");
@@ -3038,18 +2101,6 @@ var se_PutBucketTaggingCommand = /* @__PURE__ */ __name(async (input, context) =
3038
2101
  contents.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
3039
2102
  body += contents.toString();
3040
2103
  }
3041
- let { hostname: resolvedHostname } = await context.endpoint();
3042
- if (context.disableHostPrefix !== true) {
3043
- resolvedHostname = "{AccountId}." + resolvedHostname;
3044
- if (input.AccountId === void 0) {
3045
- throw new Error("Empty value provided for input host prefix: AccountId.");
3046
- }
3047
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
3048
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
3049
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
3050
- }
3051
- }
3052
- b.hn(resolvedHostname);
3053
2104
  b.m("PUT").h(headers).b(body);
3054
2105
  return b.build();
3055
2106
  }, "se_PutBucketTaggingCommand");
@@ -3070,18 +2121,6 @@ var se_PutBucketVersioningCommand = /* @__PURE__ */ __name(async (input, context
3070
2121
  contents.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
3071
2122
  body += contents.toString();
3072
2123
  }
3073
- let { hostname: resolvedHostname } = await context.endpoint();
3074
- if (context.disableHostPrefix !== true) {
3075
- resolvedHostname = "{AccountId}." + resolvedHostname;
3076
- if (input.AccountId === void 0) {
3077
- throw new Error("Empty value provided for input host prefix: AccountId.");
3078
- }
3079
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
3080
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
3081
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
3082
- }
3083
- }
3084
- b.hn(resolvedHostname);
3085
2124
  b.m("PUT").h(headers).b(body);
3086
2125
  return b.build();
3087
2126
  }, "se_PutBucketVersioningCommand");
@@ -3099,18 +2138,6 @@ var se_PutJobTaggingCommand = /* @__PURE__ */ __name(async (input, context) => {
3099
2138
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
3100
2139
  bn.lc(input, "Tags", "Tags", () => se_S3TagSet(input[_T], context));
3101
2140
  body += bn.toString();
3102
- let { hostname: resolvedHostname } = await context.endpoint();
3103
- if (context.disableHostPrefix !== true) {
3104
- resolvedHostname = "{AccountId}." + resolvedHostname;
3105
- if (input.AccountId === void 0) {
3106
- throw new Error("Empty value provided for input host prefix: AccountId.");
3107
- }
3108
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
3109
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
3110
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
3111
- }
3112
- }
3113
- b.hn(resolvedHostname);
3114
2141
  b.m("PUT").h(headers).b(body);
3115
2142
  return b.build();
3116
2143
  }, "se_PutJobTaggingCommand");
@@ -3135,18 +2162,6 @@ var se_PutMultiRegionAccessPointPolicyCommand = /* @__PURE__ */ __name(async (in
3135
2162
  bn.c(se_PutMultiRegionAccessPointPolicyInput(input[_De], context).n(_De));
3136
2163
  }
3137
2164
  body += bn.toString();
3138
- let { hostname: resolvedHostname } = await context.endpoint();
3139
- if (context.disableHostPrefix !== true) {
3140
- resolvedHostname = "{AccountId}." + resolvedHostname;
3141
- if (input.AccountId === void 0) {
3142
- throw new Error("Empty value provided for input host prefix: AccountId.");
3143
- }
3144
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
3145
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
3146
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
3147
- }
3148
- }
3149
- b.hn(resolvedHostname);
3150
2165
  b.m("POST").h(headers).b(body);
3151
2166
  return b.build();
3152
2167
  }, "se_PutMultiRegionAccessPointPolicyCommand");
@@ -3165,18 +2180,6 @@ var se_PutPublicAccessBlockCommand = /* @__PURE__ */ __name(async (input, contex
3165
2180
  contents.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
3166
2181
  body += contents.toString();
3167
2182
  }
3168
- let { hostname: resolvedHostname } = await context.endpoint();
3169
- if (context.disableHostPrefix !== true) {
3170
- resolvedHostname = "{AccountId}." + resolvedHostname;
3171
- if (input.AccountId === void 0) {
3172
- throw new Error("Empty value provided for input host prefix: AccountId.");
3173
- }
3174
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
3175
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
3176
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
3177
- }
3178
- }
3179
- b.hn(resolvedHostname);
3180
2183
  b.m("PUT").h(headers).b(body);
3181
2184
  return b.build();
3182
2185
  }, "se_PutPublicAccessBlockCommand");
@@ -3197,18 +2200,6 @@ var se_PutStorageLensConfigurationCommand = /* @__PURE__ */ __name(async (input,
3197
2200
  }
3198
2201
  bn.lc(input, "Tags", "Tags", () => se_StorageLensTags(input[_T], context));
3199
2202
  body += bn.toString();
3200
- let { hostname: resolvedHostname } = await context.endpoint();
3201
- if (context.disableHostPrefix !== true) {
3202
- resolvedHostname = "{AccountId}." + resolvedHostname;
3203
- if (input.AccountId === void 0) {
3204
- throw new Error("Empty value provided for input host prefix: AccountId.");
3205
- }
3206
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
3207
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
3208
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
3209
- }
3210
- }
3211
- b.hn(resolvedHostname);
3212
2203
  b.m("PUT").h(headers).b(body);
3213
2204
  return b.build();
3214
2205
  }, "se_PutStorageLensConfigurationCommand");
@@ -3226,18 +2217,6 @@ var se_PutStorageLensConfigurationTaggingCommand = /* @__PURE__ */ __name(async
3226
2217
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
3227
2218
  bn.lc(input, "Tags", "Tags", () => se_StorageLensTags(input[_T], context));
3228
2219
  body += bn.toString();
3229
- let { hostname: resolvedHostname } = await context.endpoint();
3230
- if (context.disableHostPrefix !== true) {
3231
- resolvedHostname = "{AccountId}." + resolvedHostname;
3232
- if (input.AccountId === void 0) {
3233
- throw new Error("Empty value provided for input host prefix: AccountId.");
3234
- }
3235
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
3236
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
3237
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
3238
- }
3239
- }
3240
- b.hn(resolvedHostname);
3241
2220
  b.m("PUT").h(headers).b(body);
3242
2221
  return b.build();
3243
2222
  }, "se_PutStorageLensConfigurationTaggingCommand");
@@ -3255,18 +2234,6 @@ var se_SubmitMultiRegionAccessPointRoutesCommand = /* @__PURE__ */ __name(async
3255
2234
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
3256
2235
  bn.lc(input, "RouteUpdates", "RouteUpdates", () => se_RouteList(input[_RU], context));
3257
2236
  body += bn.toString();
3258
- let { hostname: resolvedHostname } = await context.endpoint();
3259
- if (context.disableHostPrefix !== true) {
3260
- resolvedHostname = "{AccountId}." + resolvedHostname;
3261
- if (input.AccountId === void 0) {
3262
- throw new Error("Empty value provided for input host prefix: AccountId.");
3263
- }
3264
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
3265
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
3266
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
3267
- }
3268
- }
3269
- b.hn(resolvedHostname);
3270
2237
  b.m("PATCH").h(headers).b(body);
3271
2238
  return b.build();
3272
2239
  }, "se_SubmitMultiRegionAccessPointRoutesCommand");
@@ -3284,18 +2251,6 @@ var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
3284
2251
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
3285
2252
  bn.lc(input, "Tags", "Tags", () => se_TagList(input[_T], context));
3286
2253
  body += bn.toString();
3287
- let { hostname: resolvedHostname } = await context.endpoint();
3288
- if (context.disableHostPrefix !== true) {
3289
- resolvedHostname = "{AccountId}." + resolvedHostname;
3290
- if (input.AccountId === void 0) {
3291
- throw new Error("Empty value provided for input host prefix: AccountId.");
3292
- }
3293
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
3294
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
3295
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
3296
- }
3297
- }
3298
- b.hn(resolvedHostname);
3299
2254
  b.m("POST").h(headers).b(body);
3300
2255
  return b.build();
3301
2256
  }, "se_TagResourceCommand");
@@ -3310,18 +2265,6 @@ var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
3310
2265
  [_tK]: [(0, import_smithy_client.expectNonNull)(input.TagKeys, `TagKeys`) != null, () => input[_TK] || []]
3311
2266
  });
3312
2267
  let body;
3313
- let { hostname: resolvedHostname } = await context.endpoint();
3314
- if (context.disableHostPrefix !== true) {
3315
- resolvedHostname = "{AccountId}." + resolvedHostname;
3316
- if (input.AccountId === void 0) {
3317
- throw new Error("Empty value provided for input host prefix: AccountId.");
3318
- }
3319
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
3320
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
3321
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
3322
- }
3323
- }
3324
- b.hn(resolvedHostname);
3325
2268
  b.m("DELETE").h(headers).q(query).b(body);
3326
2269
  return b.build();
3327
2270
  }, "se_UntagResourceCommand");
@@ -3339,18 +2282,6 @@ var se_UpdateAccessGrantsLocationCommand = /* @__PURE__ */ __name(async (input,
3339
2282
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
3340
2283
  bn.cc(input, _IAMRA);
3341
2284
  body += bn.toString();
3342
- let { hostname: resolvedHostname } = await context.endpoint();
3343
- if (context.disableHostPrefix !== true) {
3344
- resolvedHostname = "{AccountId}." + resolvedHostname;
3345
- if (input.AccountId === void 0) {
3346
- throw new Error("Empty value provided for input host prefix: AccountId.");
3347
- }
3348
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
3349
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
3350
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
3351
- }
3352
- }
3353
- b.hn(resolvedHostname);
3354
2285
  b.m("PUT").h(headers).b(body);
3355
2286
  return b.build();
3356
2287
  }, "se_UpdateAccessGrantsLocationCommand");
@@ -3365,18 +2296,6 @@ var se_UpdateJobPriorityCommand = /* @__PURE__ */ __name(async (input, context)
3365
2296
  [_pri]: [(0, import_smithy_client.expectNonNull)(input.Priority, `Priority`) != null, () => input[_Pr].toString()]
3366
2297
  });
3367
2298
  let body;
3368
- let { hostname: resolvedHostname } = await context.endpoint();
3369
- if (context.disableHostPrefix !== true) {
3370
- resolvedHostname = "{AccountId}." + resolvedHostname;
3371
- if (input.AccountId === void 0) {
3372
- throw new Error("Empty value provided for input host prefix: AccountId.");
3373
- }
3374
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
3375
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
3376
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
3377
- }
3378
- }
3379
- b.hn(resolvedHostname);
3380
2299
  b.m("POST").h(headers).q(query).b(body);
3381
2300
  return b.build();
3382
2301
  }, "se_UpdateJobPriorityCommand");
@@ -3392,18 +2311,6 @@ var se_UpdateJobStatusCommand = /* @__PURE__ */ __name(async (input, context) =>
3392
2311
  [_sUR]: [, input[_SUR]]
3393
2312
  });
3394
2313
  let body;
3395
- let { hostname: resolvedHostname } = await context.endpoint();
3396
- if (context.disableHostPrefix !== true) {
3397
- resolvedHostname = "{AccountId}." + resolvedHostname;
3398
- if (input.AccountId === void 0) {
3399
- throw new Error("Empty value provided for input host prefix: AccountId.");
3400
- }
3401
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
3402
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
3403
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
3404
- }
3405
- }
3406
- b.hn(resolvedHostname);
3407
2314
  b.m("POST").h(headers).q(query).b(body);
3408
2315
  return b.build();
3409
2316
  }, "se_UpdateJobStatusCommand");
@@ -3423,18 +2330,6 @@ var se_UpdateStorageLensGroupCommand = /* @__PURE__ */ __name(async (input, cont
3423
2330
  bn.c(se_StorageLensGroup(input[_SLG], context).n(_SLG));
3424
2331
  }
3425
2332
  body += bn.toString();
3426
- let { hostname: resolvedHostname } = await context.endpoint();
3427
- if (context.disableHostPrefix !== true) {
3428
- resolvedHostname = "{AccountId}." + resolvedHostname;
3429
- if (input.AccountId === void 0) {
3430
- throw new Error("Empty value provided for input host prefix: AccountId.");
3431
- }
3432
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
3433
- if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
3434
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
3435
- }
3436
- }
3437
- b.hn(resolvedHostname);
3438
2333
  b.m("PUT").h(headers).b(body);
3439
2334
  return b.build();
3440
2335
  }, "se_UpdateStorageLensGroupCommand");