@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-es/protocols/Aws_restXml.js CHANGED
@@ -1,7 +1,6 @@
1
1
  import { loadRestXmlErrorCode, parseXmlBody as parseBody, parseXmlErrorBody as parseErrorBody } from "@aws-sdk/core";
2
2
  import { XmlNode as __XmlNode, XmlText as __XmlText } from "@aws-sdk/xml-builder";
3
3
  import { requestBuilder as rb } from "@smithy/core";
4
- import { isValidHostname as __isValidHostname, } from "@smithy/protocol-http";
5
4
  import { collectBody, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, expectUnion as __expectUnion, getArrayIfSingleItem as __getArrayIfSingleItem, isSerializableHeaderValue, map, parseBoolean as __parseBoolean, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, serializeDateTime as __serializeDateTime, strictParseFloat as __strictParseFloat, strictParseInt32 as __strictParseInt32, strictParseLong as __strictParseLong, withBaseException, } from "@smithy/smithy-client";
6
5
  import { v4 as generateIdempotencyToken } from "uuid";
7
6
  import { BadRequestException, BucketAlreadyExists, BucketAlreadyOwnedByYou, IdempotencyException, InternalServiceException, InvalidNextTokenException, InvalidRequestException, JobManifestGenerator, NoSuchPublicAccessBlockConfiguration, NotFoundException, ObjectLambdaContentTransformation, TooManyRequestsException, } from "../models/models_0";
@@ -20,18 +19,6 @@ export const se_AssociateAccessGrantsIdentityCenterCommand = async (input, conte
20
19
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
21
20
  bn.cc(input, _ICA);
22
21
  body += bn.toString();
23
- let { hostname: resolvedHostname } = await context.endpoint();
24
- if (context.disableHostPrefix !== true) {
25
- resolvedHostname = "{AccountId}." + resolvedHostname;
26
- if (input.AccountId === undefined) {
27
- throw new Error("Empty value provided for input host prefix: AccountId.");
28
- }
29
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
30
- if (!__isValidHostname(resolvedHostname)) {
31
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
32
- }
33
- }
34
- b.hn(resolvedHostname);
35
22
  b.m("POST").h(headers).b(body);
36
23
  return b.build();
37
24
  };
@@ -60,18 +47,6 @@ export const se_CreateAccessGrantCommand = async (input, context) => {
60
47
  bn.cc(input, _SPT);
61
48
  bn.lc(input, "Tags", "Tags", () => se_TagList(input[_T], context));
62
49
  body += bn.toString();
63
- let { hostname: resolvedHostname } = await context.endpoint();
64
- if (context.disableHostPrefix !== true) {
65
- resolvedHostname = "{AccountId}." + resolvedHostname;
66
- if (input.AccountId === undefined) {
67
- throw new Error("Empty value provided for input host prefix: AccountId.");
68
- }
69
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
70
- if (!__isValidHostname(resolvedHostname)) {
71
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
72
- }
73
- }
74
- b.hn(resolvedHostname);
75
50
  b.m("POST").h(headers).b(body);
76
51
  return b.build();
77
52
  };
@@ -89,18 +64,6 @@ export const se_CreateAccessGrantsInstanceCommand = async (input, context) => {
89
64
  bn.cc(input, _ICA);
90
65
  bn.lc(input, "Tags", "Tags", () => se_TagList(input[_T], context));
91
66
  body += bn.toString();
92
- let { hostname: resolvedHostname } = await context.endpoint();
93
- if (context.disableHostPrefix !== true) {
94
- resolvedHostname = "{AccountId}." + resolvedHostname;
95
- if (input.AccountId === undefined) {
96
- throw new Error("Empty value provided for input host prefix: AccountId.");
97
- }
98
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
99
- if (!__isValidHostname(resolvedHostname)) {
100
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
101
- }
102
- }
103
- b.hn(resolvedHostname);
104
67
  b.m("POST").h(headers).b(body);
105
68
  return b.build();
106
69
  };
@@ -121,18 +84,6 @@ export const se_CreateAccessGrantsLocationCommand = async (input, context) => {
121
84
  }
122
85
  bn.lc(input, "Tags", "Tags", () => se_TagList(input[_T], context));
123
86
  body += bn.toString();
124
- let { hostname: resolvedHostname } = await context.endpoint();
125
- if (context.disableHostPrefix !== true) {
126
- resolvedHostname = "{AccountId}." + resolvedHostname;
127
- if (input.AccountId === undefined) {
128
- throw new Error("Empty value provided for input host prefix: AccountId.");
129
- }
130
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
131
- if (!__isValidHostname(resolvedHostname)) {
132
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
133
- }
134
- }
135
- b.hn(resolvedHostname);
136
87
  b.m("POST").h(headers).b(body);
137
88
  return b.build();
138
89
  };
@@ -164,18 +115,6 @@ export const se_CreateAccessPointCommand = async (input, context) => {
164
115
  bn.c(se_VpcConfiguration(input[_VC], context).n(_VC));
165
116
  }
166
117
  body += bn.toString();
167
- let { hostname: resolvedHostname } = await context.endpoint();
168
- if (context.disableHostPrefix !== true) {
169
- resolvedHostname = "{AccountId}." + resolvedHostname;
170
- if (input.AccountId === undefined) {
171
- throw new Error("Empty value provided for input host prefix: AccountId.");
172
- }
173
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
174
- if (!__isValidHostname(resolvedHostname)) {
175
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
176
- }
177
- }
178
- b.hn(resolvedHostname);
179
118
  b.m("PUT").h(headers).b(body);
180
119
  return b.build();
181
120
  };
@@ -195,18 +134,6 @@ export const se_CreateAccessPointForObjectLambdaCommand = async (input, context)
195
134
  bn.c(se_ObjectLambdaConfiguration(input[_C], context).n(_C));
196
135
  }
197
136
  body += bn.toString();
198
- let { hostname: resolvedHostname } = await context.endpoint();
199
- if (context.disableHostPrefix !== true) {
200
- resolvedHostname = "{AccountId}." + resolvedHostname;
201
- if (input.AccountId === undefined) {
202
- throw new Error("Empty value provided for input host prefix: AccountId.");
203
- }
204
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
205
- if (!__isValidHostname(resolvedHostname)) {
206
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
207
- }
208
- }
209
- b.hn(resolvedHostname);
210
137
  b.m("PUT").h(headers).b(body);
211
138
  return b.build();
212
139
  };
@@ -279,18 +206,6 @@ export const se_CreateJobCommand = async (input, context) => {
279
206
  }
280
207
  bn.lc(input, "Tags", "Tags", () => se_S3TagSet(input[_T], context));
281
208
  body += bn.toString();
282
- let { hostname: resolvedHostname } = await context.endpoint();
283
- if (context.disableHostPrefix !== true) {
284
- resolvedHostname = "{AccountId}." + resolvedHostname;
285
- if (input.AccountId === undefined) {
286
- throw new Error("Empty value provided for input host prefix: AccountId.");
287
- }
288
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
289
- if (!__isValidHostname(resolvedHostname)) {
290
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
291
- }
292
- }
293
- b.hn(resolvedHostname);
294
209
  b.m("POST").h(headers).b(body);
295
210
  return b.build();
296
211
  };
@@ -315,18 +230,6 @@ export const se_CreateMultiRegionAccessPointCommand = async (input, context) =>
315
230
  bn.c(se_CreateMultiRegionAccessPointInput(input[_De], context).n(_De));
316
231
  }
317
232
  body += bn.toString();
318
- let { hostname: resolvedHostname } = await context.endpoint();
319
- if (context.disableHostPrefix !== true) {
320
- resolvedHostname = "{AccountId}." + resolvedHostname;
321
- if (input.AccountId === undefined) {
322
- throw new Error("Empty value provided for input host prefix: AccountId.");
323
- }
324
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
325
- if (!__isValidHostname(resolvedHostname)) {
326
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
327
- }
328
- }
329
- b.hn(resolvedHostname);
330
233
  b.m("POST").h(headers).b(body);
331
234
  return b.build();
332
235
  };
@@ -346,18 +249,6 @@ export const se_CreateStorageLensGroupCommand = async (input, context) => {
346
249
  }
347
250
  bn.lc(input, "Tags", "Tags", () => se_TagList(input[_T], context));
348
251
  body += bn.toString();
349
- let { hostname: resolvedHostname } = await context.endpoint();
350
- if (context.disableHostPrefix !== true) {
351
- resolvedHostname = "{AccountId}." + resolvedHostname;
352
- if (input.AccountId === undefined) {
353
- throw new Error("Empty value provided for input host prefix: AccountId.");
354
- }
355
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
356
- if (!__isValidHostname(resolvedHostname)) {
357
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
358
- }
359
- }
360
- b.hn(resolvedHostname);
361
252
  b.m("POST").h(headers).b(body);
362
253
  return b.build();
363
254
  };
@@ -369,18 +260,6 @@ export const se_DeleteAccessGrantCommand = async (input, context) => {
369
260
  b.bp("/v20180820/accessgrantsinstance/grant/{AccessGrantId}");
370
261
  b.p("AccessGrantId", () => input.AccessGrantId, "{AccessGrantId}", false);
371
262
  let body;
372
- let { hostname: resolvedHostname } = await context.endpoint();
373
- if (context.disableHostPrefix !== true) {
374
- resolvedHostname = "{AccountId}." + resolvedHostname;
375
- if (input.AccountId === undefined) {
376
- throw new Error("Empty value provided for input host prefix: AccountId.");
377
- }
378
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
379
- if (!__isValidHostname(resolvedHostname)) {
380
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
381
- }
382
- }
383
- b.hn(resolvedHostname);
384
263
  b.m("DELETE").h(headers).b(body);
385
264
  return b.build();
386
265
  };
@@ -391,18 +270,6 @@ export const se_DeleteAccessGrantsInstanceCommand = async (input, context) => {
391
270
  });
392
271
  b.bp("/v20180820/accessgrantsinstance");
393
272
  let body;
394
- let { hostname: resolvedHostname } = await context.endpoint();
395
- if (context.disableHostPrefix !== true) {
396
- resolvedHostname = "{AccountId}." + resolvedHostname;
397
- if (input.AccountId === undefined) {
398
- throw new Error("Empty value provided for input host prefix: AccountId.");
399
- }
400
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
401
- if (!__isValidHostname(resolvedHostname)) {
402
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
403
- }
404
- }
405
- b.hn(resolvedHostname);
406
273
  b.m("DELETE").h(headers).b(body);
407
274
  return b.build();
408
275
  };
@@ -413,18 +280,6 @@ export const se_DeleteAccessGrantsInstanceResourcePolicyCommand = async (input,
413
280
  });
414
281
  b.bp("/v20180820/accessgrantsinstance/resourcepolicy");
415
282
  let body;
416
- let { hostname: resolvedHostname } = await context.endpoint();
417
- if (context.disableHostPrefix !== true) {
418
- resolvedHostname = "{AccountId}." + resolvedHostname;
419
- if (input.AccountId === undefined) {
420
- throw new Error("Empty value provided for input host prefix: AccountId.");
421
- }
422
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
423
- if (!__isValidHostname(resolvedHostname)) {
424
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
425
- }
426
- }
427
- b.hn(resolvedHostname);
428
283
  b.m("DELETE").h(headers).b(body);
429
284
  return b.build();
430
285
  };
@@ -436,18 +291,6 @@ export const se_DeleteAccessGrantsLocationCommand = async (input, context) => {
436
291
  b.bp("/v20180820/accessgrantsinstance/location/{AccessGrantsLocationId}");
437
292
  b.p("AccessGrantsLocationId", () => input.AccessGrantsLocationId, "{AccessGrantsLocationId}", false);
438
293
  let body;
439
- let { hostname: resolvedHostname } = await context.endpoint();
440
- if (context.disableHostPrefix !== true) {
441
- resolvedHostname = "{AccountId}." + resolvedHostname;
442
- if (input.AccountId === undefined) {
443
- throw new Error("Empty value provided for input host prefix: AccountId.");
444
- }
445
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
446
- if (!__isValidHostname(resolvedHostname)) {
447
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
448
- }
449
- }
450
- b.hn(resolvedHostname);
451
294
  b.m("DELETE").h(headers).b(body);
452
295
  return b.build();
453
296
  };
@@ -459,18 +302,6 @@ export const se_DeleteAccessPointCommand = async (input, context) => {
459
302
  b.bp("/v20180820/accesspoint/{Name}");
460
303
  b.p("Name", () => input.Name, "{Name}", false);
461
304
  let body;
462
- let { hostname: resolvedHostname } = await context.endpoint();
463
- if (context.disableHostPrefix !== true) {
464
- resolvedHostname = "{AccountId}." + resolvedHostname;
465
- if (input.AccountId === undefined) {
466
- throw new Error("Empty value provided for input host prefix: AccountId.");
467
- }
468
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
469
- if (!__isValidHostname(resolvedHostname)) {
470
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
471
- }
472
- }
473
- b.hn(resolvedHostname);
474
305
  b.m("DELETE").h(headers).b(body);
475
306
  return b.build();
476
307
  };
@@ -482,18 +313,6 @@ export const se_DeleteAccessPointForObjectLambdaCommand = async (input, context)
482
313
  b.bp("/v20180820/accesspointforobjectlambda/{Name}");
483
314
  b.p("Name", () => input.Name, "{Name}", false);
484
315
  let body;
485
- let { hostname: resolvedHostname } = await context.endpoint();
486
- if (context.disableHostPrefix !== true) {
487
- resolvedHostname = "{AccountId}." + resolvedHostname;
488
- if (input.AccountId === undefined) {
489
- throw new Error("Empty value provided for input host prefix: AccountId.");
490
- }
491
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
492
- if (!__isValidHostname(resolvedHostname)) {
493
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
494
- }
495
- }
496
- b.hn(resolvedHostname);
497
316
  b.m("DELETE").h(headers).b(body);
498
317
  return b.build();
499
318
  };
@@ -505,18 +324,6 @@ export const se_DeleteAccessPointPolicyCommand = async (input, context) => {
505
324
  b.bp("/v20180820/accesspoint/{Name}/policy");
506
325
  b.p("Name", () => input.Name, "{Name}", false);
507
326
  let body;
508
- let { hostname: resolvedHostname } = await context.endpoint();
509
- if (context.disableHostPrefix !== true) {
510
- resolvedHostname = "{AccountId}." + resolvedHostname;
511
- if (input.AccountId === undefined) {
512
- throw new Error("Empty value provided for input host prefix: AccountId.");
513
- }
514
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
515
- if (!__isValidHostname(resolvedHostname)) {
516
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
517
- }
518
- }
519
- b.hn(resolvedHostname);
520
327
  b.m("DELETE").h(headers).b(body);
521
328
  return b.build();
522
329
  };
@@ -528,18 +335,6 @@ export const se_DeleteAccessPointPolicyForObjectLambdaCommand = async (input, co
528
335
  b.bp("/v20180820/accesspointforobjectlambda/{Name}/policy");
529
336
  b.p("Name", () => input.Name, "{Name}", false);
530
337
  let body;
531
- let { hostname: resolvedHostname } = await context.endpoint();
532
- if (context.disableHostPrefix !== true) {
533
- resolvedHostname = "{AccountId}." + resolvedHostname;
534
- if (input.AccountId === undefined) {
535
- throw new Error("Empty value provided for input host prefix: AccountId.");
536
- }
537
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
538
- if (!__isValidHostname(resolvedHostname)) {
539
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
540
- }
541
- }
542
- b.hn(resolvedHostname);
543
338
  b.m("DELETE").h(headers).b(body);
544
339
  return b.build();
545
340
  };
@@ -562,18 +357,6 @@ export const se_DeleteBucketCommand = async (input, context) => {
562
357
  b.bp("/v20180820/bucket/{Bucket}");
563
358
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
564
359
  let body;
565
- let { hostname: resolvedHostname } = await context.endpoint();
566
- if (context.disableHostPrefix !== true) {
567
- resolvedHostname = "{AccountId}." + resolvedHostname;
568
- if (input.AccountId === undefined) {
569
- throw new Error("Empty value provided for input host prefix: AccountId.");
570
- }
571
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
572
- if (!__isValidHostname(resolvedHostname)) {
573
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
574
- }
575
- }
576
- b.hn(resolvedHostname);
577
360
  b.m("DELETE").h(headers).b(body);
578
361
  return b.build();
579
362
  };
@@ -585,18 +368,6 @@ export const se_DeleteBucketLifecycleConfigurationCommand = async (input, contex
585
368
  b.bp("/v20180820/bucket/{Bucket}/lifecycleconfiguration");
586
369
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
587
370
  let body;
588
- let { hostname: resolvedHostname } = await context.endpoint();
589
- if (context.disableHostPrefix !== true) {
590
- resolvedHostname = "{AccountId}." + resolvedHostname;
591
- if (input.AccountId === undefined) {
592
- throw new Error("Empty value provided for input host prefix: AccountId.");
593
- }
594
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
595
- if (!__isValidHostname(resolvedHostname)) {
596
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
597
- }
598
- }
599
- b.hn(resolvedHostname);
600
371
  b.m("DELETE").h(headers).b(body);
601
372
  return b.build();
602
373
  };
@@ -608,18 +379,6 @@ export const se_DeleteBucketPolicyCommand = async (input, context) => {
608
379
  b.bp("/v20180820/bucket/{Bucket}/policy");
609
380
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
610
381
  let body;
611
- let { hostname: resolvedHostname } = await context.endpoint();
612
- if (context.disableHostPrefix !== true) {
613
- resolvedHostname = "{AccountId}." + resolvedHostname;
614
- if (input.AccountId === undefined) {
615
- throw new Error("Empty value provided for input host prefix: AccountId.");
616
- }
617
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
618
- if (!__isValidHostname(resolvedHostname)) {
619
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
620
- }
621
- }
622
- b.hn(resolvedHostname);
623
382
  b.m("DELETE").h(headers).b(body);
624
383
  return b.build();
625
384
  };
@@ -631,18 +390,6 @@ export const se_DeleteBucketReplicationCommand = async (input, context) => {
631
390
  b.bp("/v20180820/bucket/{Bucket}/replication");
632
391
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
633
392
  let body;
634
- let { hostname: resolvedHostname } = await context.endpoint();
635
- if (context.disableHostPrefix !== true) {
636
- resolvedHostname = "{AccountId}." + resolvedHostname;
637
- if (input.AccountId === undefined) {
638
- throw new Error("Empty value provided for input host prefix: AccountId.");
639
- }
640
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
641
- if (!__isValidHostname(resolvedHostname)) {
642
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
643
- }
644
- }
645
- b.hn(resolvedHostname);
646
393
  b.m("DELETE").h(headers).b(body);
647
394
  return b.build();
648
395
  };
@@ -654,18 +401,6 @@ export const se_DeleteBucketTaggingCommand = async (input, context) => {
654
401
  b.bp("/v20180820/bucket/{Bucket}/tagging");
655
402
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
656
403
  let body;
657
- let { hostname: resolvedHostname } = await context.endpoint();
658
- if (context.disableHostPrefix !== true) {
659
- resolvedHostname = "{AccountId}." + resolvedHostname;
660
- if (input.AccountId === undefined) {
661
- throw new Error("Empty value provided for input host prefix: AccountId.");
662
- }
663
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
664
- if (!__isValidHostname(resolvedHostname)) {
665
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
666
- }
667
- }
668
- b.hn(resolvedHostname);
669
404
  b.m("DELETE").h(headers).b(body);
670
405
  return b.build();
671
406
  };
@@ -677,18 +412,6 @@ export const se_DeleteJobTaggingCommand = async (input, context) => {
677
412
  b.bp("/v20180820/jobs/{JobId}/tagging");
678
413
  b.p("JobId", () => input.JobId, "{JobId}", false);
679
414
  let body;
680
- let { hostname: resolvedHostname } = await context.endpoint();
681
- if (context.disableHostPrefix !== true) {
682
- resolvedHostname = "{AccountId}." + resolvedHostname;
683
- if (input.AccountId === undefined) {
684
- throw new Error("Empty value provided for input host prefix: AccountId.");
685
- }
686
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
687
- if (!__isValidHostname(resolvedHostname)) {
688
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
689
- }
690
- }
691
- b.hn(resolvedHostname);
692
415
  b.m("DELETE").h(headers).b(body);
693
416
  return b.build();
694
417
  };
@@ -713,18 +436,6 @@ export const se_DeleteMultiRegionAccessPointCommand = async (input, context) =>
713
436
  bn.c(se_DeleteMultiRegionAccessPointInput(input[_De], context).n(_De));
714
437
  }
715
438
  body += bn.toString();
716
- let { hostname: resolvedHostname } = await context.endpoint();
717
- if (context.disableHostPrefix !== true) {
718
- resolvedHostname = "{AccountId}." + resolvedHostname;
719
- if (input.AccountId === undefined) {
720
- throw new Error("Empty value provided for input host prefix: AccountId.");
721
- }
722
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
723
- if (!__isValidHostname(resolvedHostname)) {
724
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
725
- }
726
- }
727
- b.hn(resolvedHostname);
728
439
  b.m("POST").h(headers).b(body);
729
440
  return b.build();
730
441
  };
@@ -735,18 +446,6 @@ export const se_DeletePublicAccessBlockCommand = async (input, context) => {
735
446
  });
736
447
  b.bp("/v20180820/configuration/publicAccessBlock");
737
448
  let body;
738
- let { hostname: resolvedHostname } = await context.endpoint();
739
- if (context.disableHostPrefix !== true) {
740
- resolvedHostname = "{AccountId}." + resolvedHostname;
741
- if (input.AccountId === undefined) {
742
- throw new Error("Empty value provided for input host prefix: AccountId.");
743
- }
744
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
745
- if (!__isValidHostname(resolvedHostname)) {
746
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
747
- }
748
- }
749
- b.hn(resolvedHostname);
750
449
  b.m("DELETE").h(headers).b(body);
751
450
  return b.build();
752
451
  };
@@ -758,18 +457,6 @@ export const se_DeleteStorageLensConfigurationCommand = async (input, context) =
758
457
  b.bp("/v20180820/storagelens/{ConfigId}");
759
458
  b.p("ConfigId", () => input.ConfigId, "{ConfigId}", false);
760
459
  let body;
761
- let { hostname: resolvedHostname } = await context.endpoint();
762
- if (context.disableHostPrefix !== true) {
763
- resolvedHostname = "{AccountId}." + resolvedHostname;
764
- if (input.AccountId === undefined) {
765
- throw new Error("Empty value provided for input host prefix: AccountId.");
766
- }
767
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
768
- if (!__isValidHostname(resolvedHostname)) {
769
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
770
- }
771
- }
772
- b.hn(resolvedHostname);
773
460
  b.m("DELETE").h(headers).b(body);
774
461
  return b.build();
775
462
  };
@@ -781,18 +468,6 @@ export const se_DeleteStorageLensConfigurationTaggingCommand = async (input, con
781
468
  b.bp("/v20180820/storagelens/{ConfigId}/tagging");
782
469
  b.p("ConfigId", () => input.ConfigId, "{ConfigId}", false);
783
470
  let body;
784
- let { hostname: resolvedHostname } = await context.endpoint();
785
- if (context.disableHostPrefix !== true) {
786
- resolvedHostname = "{AccountId}." + resolvedHostname;
787
- if (input.AccountId === undefined) {
788
- throw new Error("Empty value provided for input host prefix: AccountId.");
789
- }
790
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
791
- if (!__isValidHostname(resolvedHostname)) {
792
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
793
- }
794
- }
795
- b.hn(resolvedHostname);
796
471
  b.m("DELETE").h(headers).b(body);
797
472
  return b.build();
798
473
  };
@@ -804,18 +479,6 @@ export const se_DeleteStorageLensGroupCommand = async (input, context) => {
804
479
  b.bp("/v20180820/storagelensgroup/{Name}");
805
480
  b.p("Name", () => input.Name, "{Name}", false);
806
481
  let body;
807
- let { hostname: resolvedHostname } = await context.endpoint();
808
- if (context.disableHostPrefix !== true) {
809
- resolvedHostname = "{AccountId}." + resolvedHostname;
810
- if (input.AccountId === undefined) {
811
- throw new Error("Empty value provided for input host prefix: AccountId.");
812
- }
813
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
814
- if (!__isValidHostname(resolvedHostname)) {
815
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
816
- }
817
- }
818
- b.hn(resolvedHostname);
819
482
  b.m("DELETE").h(headers).b(body);
820
483
  return b.build();
821
484
  };
@@ -827,18 +490,6 @@ export const se_DescribeJobCommand = async (input, context) => {
827
490
  b.bp("/v20180820/jobs/{JobId}");
828
491
  b.p("JobId", () => input.JobId, "{JobId}", false);
829
492
  let body;
830
- let { hostname: resolvedHostname } = await context.endpoint();
831
- if (context.disableHostPrefix !== true) {
832
- resolvedHostname = "{AccountId}." + resolvedHostname;
833
- if (input.AccountId === undefined) {
834
- throw new Error("Empty value provided for input host prefix: AccountId.");
835
- }
836
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
837
- if (!__isValidHostname(resolvedHostname)) {
838
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
839
- }
840
- }
841
- b.hn(resolvedHostname);
842
493
  b.m("GET").h(headers).b(body);
843
494
  return b.build();
844
495
  };
@@ -850,18 +501,6 @@ export const se_DescribeMultiRegionAccessPointOperationCommand = async (input, c
850
501
  b.bp("/v20180820/async-requests/mrap/{RequestTokenARN+}");
851
502
  b.p("RequestTokenARN", () => input.RequestTokenARN, "{RequestTokenARN+}", true);
852
503
  let body;
853
- let { hostname: resolvedHostname } = await context.endpoint();
854
- if (context.disableHostPrefix !== true) {
855
- resolvedHostname = "{AccountId}." + resolvedHostname;
856
- if (input.AccountId === undefined) {
857
- throw new Error("Empty value provided for input host prefix: AccountId.");
858
- }
859
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
860
- if (!__isValidHostname(resolvedHostname)) {
861
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
862
- }
863
- }
864
- b.hn(resolvedHostname);
865
504
  b.m("GET").h(headers).b(body);
866
505
  return b.build();
867
506
  };
@@ -872,18 +511,6 @@ export const se_DissociateAccessGrantsIdentityCenterCommand = async (input, cont
872
511
  });
873
512
  b.bp("/v20180820/accessgrantsinstance/identitycenter");
874
513
  let body;
875
- let { hostname: resolvedHostname } = await context.endpoint();
876
- if (context.disableHostPrefix !== true) {
877
- resolvedHostname = "{AccountId}." + resolvedHostname;
878
- if (input.AccountId === undefined) {
879
- throw new Error("Empty value provided for input host prefix: AccountId.");
880
- }
881
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
882
- if (!__isValidHostname(resolvedHostname)) {
883
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
884
- }
885
- }
886
- b.hn(resolvedHostname);
887
514
  b.m("DELETE").h(headers).b(body);
888
515
  return b.build();
889
516
  };
@@ -895,18 +522,6 @@ export const se_GetAccessGrantCommand = async (input, context) => {
895
522
  b.bp("/v20180820/accessgrantsinstance/grant/{AccessGrantId}");
896
523
  b.p("AccessGrantId", () => input.AccessGrantId, "{AccessGrantId}", false);
897
524
  let body;
898
- let { hostname: resolvedHostname } = await context.endpoint();
899
- if (context.disableHostPrefix !== true) {
900
- resolvedHostname = "{AccountId}." + resolvedHostname;
901
- if (input.AccountId === undefined) {
902
- throw new Error("Empty value provided for input host prefix: AccountId.");
903
- }
904
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
905
- if (!__isValidHostname(resolvedHostname)) {
906
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
907
- }
908
- }
909
- b.hn(resolvedHostname);
910
525
  b.m("GET").h(headers).b(body);
911
526
  return b.build();
912
527
  };
@@ -917,18 +532,6 @@ export const se_GetAccessGrantsInstanceCommand = async (input, context) => {
917
532
  });
918
533
  b.bp("/v20180820/accessgrantsinstance");
919
534
  let body;
920
- let { hostname: resolvedHostname } = await context.endpoint();
921
- if (context.disableHostPrefix !== true) {
922
- resolvedHostname = "{AccountId}." + resolvedHostname;
923
- if (input.AccountId === undefined) {
924
- throw new Error("Empty value provided for input host prefix: AccountId.");
925
- }
926
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
927
- if (!__isValidHostname(resolvedHostname)) {
928
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
929
- }
930
- }
931
- b.hn(resolvedHostname);
932
535
  b.m("GET").h(headers).b(body);
933
536
  return b.build();
934
537
  };
@@ -942,18 +545,6 @@ export const se_GetAccessGrantsInstanceForPrefixCommand = async (input, context)
942
545
  [_s]: [, __expectNonNull(input[_SP], `S3Prefix`)],
943
546
  });
944
547
  let body;
945
- let { hostname: resolvedHostname } = await context.endpoint();
946
- if (context.disableHostPrefix !== true) {
947
- resolvedHostname = "{AccountId}." + resolvedHostname;
948
- if (input.AccountId === undefined) {
949
- throw new Error("Empty value provided for input host prefix: AccountId.");
950
- }
951
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
952
- if (!__isValidHostname(resolvedHostname)) {
953
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
954
- }
955
- }
956
- b.hn(resolvedHostname);
957
548
  b.m("GET").h(headers).q(query).b(body);
958
549
  return b.build();
959
550
  };
@@ -964,18 +555,6 @@ export const se_GetAccessGrantsInstanceResourcePolicyCommand = async (input, con
964
555
  });
965
556
  b.bp("/v20180820/accessgrantsinstance/resourcepolicy");
966
557
  let body;
967
- let { hostname: resolvedHostname } = await context.endpoint();
968
- if (context.disableHostPrefix !== true) {
969
- resolvedHostname = "{AccountId}." + resolvedHostname;
970
- if (input.AccountId === undefined) {
971
- throw new Error("Empty value provided for input host prefix: AccountId.");
972
- }
973
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
974
- if (!__isValidHostname(resolvedHostname)) {
975
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
976
- }
977
- }
978
- b.hn(resolvedHostname);
979
558
  b.m("GET").h(headers).b(body);
980
559
  return b.build();
981
560
  };
@@ -987,18 +566,6 @@ export const se_GetAccessGrantsLocationCommand = async (input, context) => {
987
566
  b.bp("/v20180820/accessgrantsinstance/location/{AccessGrantsLocationId}");
988
567
  b.p("AccessGrantsLocationId", () => input.AccessGrantsLocationId, "{AccessGrantsLocationId}", false);
989
568
  let body;
990
- let { hostname: resolvedHostname } = await context.endpoint();
991
- if (context.disableHostPrefix !== true) {
992
- resolvedHostname = "{AccountId}." + resolvedHostname;
993
- if (input.AccountId === undefined) {
994
- throw new Error("Empty value provided for input host prefix: AccountId.");
995
- }
996
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
997
- if (!__isValidHostname(resolvedHostname)) {
998
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
999
- }
1000
- }
1001
- b.hn(resolvedHostname);
1002
569
  b.m("GET").h(headers).b(body);
1003
570
  return b.build();
1004
571
  };
@@ -1010,18 +577,6 @@ export const se_GetAccessPointCommand = async (input, context) => {
1010
577
  b.bp("/v20180820/accesspoint/{Name}");
1011
578
  b.p("Name", () => input.Name, "{Name}", false);
1012
579
  let body;
1013
- let { hostname: resolvedHostname } = await context.endpoint();
1014
- if (context.disableHostPrefix !== true) {
1015
- resolvedHostname = "{AccountId}." + resolvedHostname;
1016
- if (input.AccountId === undefined) {
1017
- throw new Error("Empty value provided for input host prefix: AccountId.");
1018
- }
1019
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1020
- if (!__isValidHostname(resolvedHostname)) {
1021
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1022
- }
1023
- }
1024
- b.hn(resolvedHostname);
1025
580
  b.m("GET").h(headers).b(body);
1026
581
  return b.build();
1027
582
  };
@@ -1033,18 +588,6 @@ export const se_GetAccessPointConfigurationForObjectLambdaCommand = async (input
1033
588
  b.bp("/v20180820/accesspointforobjectlambda/{Name}/configuration");
1034
589
  b.p("Name", () => input.Name, "{Name}", false);
1035
590
  let body;
1036
- let { hostname: resolvedHostname } = await context.endpoint();
1037
- if (context.disableHostPrefix !== true) {
1038
- resolvedHostname = "{AccountId}." + resolvedHostname;
1039
- if (input.AccountId === undefined) {
1040
- throw new Error("Empty value provided for input host prefix: AccountId.");
1041
- }
1042
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1043
- if (!__isValidHostname(resolvedHostname)) {
1044
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1045
- }
1046
- }
1047
- b.hn(resolvedHostname);
1048
591
  b.m("GET").h(headers).b(body);
1049
592
  return b.build();
1050
593
  };
@@ -1056,18 +599,6 @@ export const se_GetAccessPointForObjectLambdaCommand = async (input, context) =>
1056
599
  b.bp("/v20180820/accesspointforobjectlambda/{Name}");
1057
600
  b.p("Name", () => input.Name, "{Name}", false);
1058
601
  let body;
1059
- let { hostname: resolvedHostname } = await context.endpoint();
1060
- if (context.disableHostPrefix !== true) {
1061
- resolvedHostname = "{AccountId}." + resolvedHostname;
1062
- if (input.AccountId === undefined) {
1063
- throw new Error("Empty value provided for input host prefix: AccountId.");
1064
- }
1065
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1066
- if (!__isValidHostname(resolvedHostname)) {
1067
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1068
- }
1069
- }
1070
- b.hn(resolvedHostname);
1071
602
  b.m("GET").h(headers).b(body);
1072
603
  return b.build();
1073
604
  };
@@ -1079,18 +610,6 @@ export const se_GetAccessPointPolicyCommand = async (input, context) => {
1079
610
  b.bp("/v20180820/accesspoint/{Name}/policy");
1080
611
  b.p("Name", () => input.Name, "{Name}", false);
1081
612
  let body;
1082
- let { hostname: resolvedHostname } = await context.endpoint();
1083
- if (context.disableHostPrefix !== true) {
1084
- resolvedHostname = "{AccountId}." + resolvedHostname;
1085
- if (input.AccountId === undefined) {
1086
- throw new Error("Empty value provided for input host prefix: AccountId.");
1087
- }
1088
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1089
- if (!__isValidHostname(resolvedHostname)) {
1090
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1091
- }
1092
- }
1093
- b.hn(resolvedHostname);
1094
613
  b.m("GET").h(headers).b(body);
1095
614
  return b.build();
1096
615
  };
@@ -1102,18 +621,6 @@ export const se_GetAccessPointPolicyForObjectLambdaCommand = async (input, conte
1102
621
  b.bp("/v20180820/accesspointforobjectlambda/{Name}/policy");
1103
622
  b.p("Name", () => input.Name, "{Name}", false);
1104
623
  let body;
1105
- let { hostname: resolvedHostname } = await context.endpoint();
1106
- if (context.disableHostPrefix !== true) {
1107
- resolvedHostname = "{AccountId}." + resolvedHostname;
1108
- if (input.AccountId === undefined) {
1109
- throw new Error("Empty value provided for input host prefix: AccountId.");
1110
- }
1111
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1112
- if (!__isValidHostname(resolvedHostname)) {
1113
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1114
- }
1115
- }
1116
- b.hn(resolvedHostname);
1117
624
  b.m("GET").h(headers).b(body);
1118
625
  return b.build();
1119
626
  };
@@ -1125,18 +632,6 @@ export const se_GetAccessPointPolicyStatusCommand = async (input, context) => {
1125
632
  b.bp("/v20180820/accesspoint/{Name}/policyStatus");
1126
633
  b.p("Name", () => input.Name, "{Name}", false);
1127
634
  let body;
1128
- let { hostname: resolvedHostname } = await context.endpoint();
1129
- if (context.disableHostPrefix !== true) {
1130
- resolvedHostname = "{AccountId}." + resolvedHostname;
1131
- if (input.AccountId === undefined) {
1132
- throw new Error("Empty value provided for input host prefix: AccountId.");
1133
- }
1134
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1135
- if (!__isValidHostname(resolvedHostname)) {
1136
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1137
- }
1138
- }
1139
- b.hn(resolvedHostname);
1140
635
  b.m("GET").h(headers).b(body);
1141
636
  return b.build();
1142
637
  };
@@ -1148,18 +643,6 @@ export const se_GetAccessPointPolicyStatusForObjectLambdaCommand = async (input,
1148
643
  b.bp("/v20180820/accesspointforobjectlambda/{Name}/policyStatus");
1149
644
  b.p("Name", () => input.Name, "{Name}", false);
1150
645
  let body;
1151
- let { hostname: resolvedHostname } = await context.endpoint();
1152
- if (context.disableHostPrefix !== true) {
1153
- resolvedHostname = "{AccountId}." + resolvedHostname;
1154
- if (input.AccountId === undefined) {
1155
- throw new Error("Empty value provided for input host prefix: AccountId.");
1156
- }
1157
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1158
- if (!__isValidHostname(resolvedHostname)) {
1159
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1160
- }
1161
- }
1162
- b.hn(resolvedHostname);
1163
646
  b.m("GET").h(headers).b(body);
1164
647
  return b.build();
1165
648
  };
@@ -1182,18 +665,6 @@ export const se_GetBucketCommand = async (input, context) => {
1182
665
  b.bp("/v20180820/bucket/{Bucket}");
1183
666
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
1184
667
  let body;
1185
- let { hostname: resolvedHostname } = await context.endpoint();
1186
- if (context.disableHostPrefix !== true) {
1187
- resolvedHostname = "{AccountId}." + resolvedHostname;
1188
- if (input.AccountId === undefined) {
1189
- throw new Error("Empty value provided for input host prefix: AccountId.");
1190
- }
1191
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1192
- if (!__isValidHostname(resolvedHostname)) {
1193
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1194
- }
1195
- }
1196
- b.hn(resolvedHostname);
1197
668
  b.m("GET").h(headers).b(body);
1198
669
  return b.build();
1199
670
  };
@@ -1205,18 +676,6 @@ export const se_GetBucketLifecycleConfigurationCommand = async (input, context)
1205
676
  b.bp("/v20180820/bucket/{Bucket}/lifecycleconfiguration");
1206
677
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
1207
678
  let body;
1208
- let { hostname: resolvedHostname } = await context.endpoint();
1209
- if (context.disableHostPrefix !== true) {
1210
- resolvedHostname = "{AccountId}." + resolvedHostname;
1211
- if (input.AccountId === undefined) {
1212
- throw new Error("Empty value provided for input host prefix: AccountId.");
1213
- }
1214
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1215
- if (!__isValidHostname(resolvedHostname)) {
1216
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1217
- }
1218
- }
1219
- b.hn(resolvedHostname);
1220
679
  b.m("GET").h(headers).b(body);
1221
680
  return b.build();
1222
681
  };
@@ -1228,18 +687,6 @@ export const se_GetBucketPolicyCommand = async (input, context) => {
1228
687
  b.bp("/v20180820/bucket/{Bucket}/policy");
1229
688
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
1230
689
  let body;
1231
- let { hostname: resolvedHostname } = await context.endpoint();
1232
- if (context.disableHostPrefix !== true) {
1233
- resolvedHostname = "{AccountId}." + resolvedHostname;
1234
- if (input.AccountId === undefined) {
1235
- throw new Error("Empty value provided for input host prefix: AccountId.");
1236
- }
1237
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1238
- if (!__isValidHostname(resolvedHostname)) {
1239
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1240
- }
1241
- }
1242
- b.hn(resolvedHostname);
1243
690
  b.m("GET").h(headers).b(body);
1244
691
  return b.build();
1245
692
  };
@@ -1251,18 +698,6 @@ export const se_GetBucketReplicationCommand = async (input, context) => {
1251
698
  b.bp("/v20180820/bucket/{Bucket}/replication");
1252
699
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
1253
700
  let body;
1254
- let { hostname: resolvedHostname } = await context.endpoint();
1255
- if (context.disableHostPrefix !== true) {
1256
- resolvedHostname = "{AccountId}." + resolvedHostname;
1257
- if (input.AccountId === undefined) {
1258
- throw new Error("Empty value provided for input host prefix: AccountId.");
1259
- }
1260
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1261
- if (!__isValidHostname(resolvedHostname)) {
1262
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1263
- }
1264
- }
1265
- b.hn(resolvedHostname);
1266
701
  b.m("GET").h(headers).b(body);
1267
702
  return b.build();
1268
703
  };
@@ -1274,18 +709,6 @@ export const se_GetBucketTaggingCommand = async (input, context) => {
1274
709
  b.bp("/v20180820/bucket/{Bucket}/tagging");
1275
710
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
1276
711
  let body;
1277
- let { hostname: resolvedHostname } = await context.endpoint();
1278
- if (context.disableHostPrefix !== true) {
1279
- resolvedHostname = "{AccountId}." + resolvedHostname;
1280
- if (input.AccountId === undefined) {
1281
- throw new Error("Empty value provided for input host prefix: AccountId.");
1282
- }
1283
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1284
- if (!__isValidHostname(resolvedHostname)) {
1285
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1286
- }
1287
- }
1288
- b.hn(resolvedHostname);
1289
712
  b.m("GET").h(headers).b(body);
1290
713
  return b.build();
1291
714
  };
@@ -1297,18 +720,6 @@ export const se_GetBucketVersioningCommand = async (input, context) => {
1297
720
  b.bp("/v20180820/bucket/{Bucket}/versioning");
1298
721
  b.p("Bucket", () => input.Bucket, "{Bucket}", false);
1299
722
  let body;
1300
- let { hostname: resolvedHostname } = await context.endpoint();
1301
- if (context.disableHostPrefix !== true) {
1302
- resolvedHostname = "{AccountId}." + resolvedHostname;
1303
- if (input.AccountId === undefined) {
1304
- throw new Error("Empty value provided for input host prefix: AccountId.");
1305
- }
1306
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1307
- if (!__isValidHostname(resolvedHostname)) {
1308
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1309
- }
1310
- }
1311
- b.hn(resolvedHostname);
1312
723
  b.m("GET").h(headers).b(body);
1313
724
  return b.build();
1314
725
  };
@@ -1326,18 +737,6 @@ export const se_GetDataAccessCommand = async (input, context) => {
1326
737
  [_tT]: [, input[_TT]],
1327
738
  });
1328
739
  let body;
1329
- let { hostname: resolvedHostname } = await context.endpoint();
1330
- if (context.disableHostPrefix !== true) {
1331
- resolvedHostname = "{AccountId}." + resolvedHostname;
1332
- if (input.AccountId === undefined) {
1333
- throw new Error("Empty value provided for input host prefix: AccountId.");
1334
- }
1335
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1336
- if (!__isValidHostname(resolvedHostname)) {
1337
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1338
- }
1339
- }
1340
- b.hn(resolvedHostname);
1341
740
  b.m("GET").h(headers).q(query).b(body);
1342
741
  return b.build();
1343
742
  };
@@ -1349,18 +748,6 @@ export const se_GetJobTaggingCommand = async (input, context) => {
1349
748
  b.bp("/v20180820/jobs/{JobId}/tagging");
1350
749
  b.p("JobId", () => input.JobId, "{JobId}", false);
1351
750
  let body;
1352
- let { hostname: resolvedHostname } = await context.endpoint();
1353
- if (context.disableHostPrefix !== true) {
1354
- resolvedHostname = "{AccountId}." + resolvedHostname;
1355
- if (input.AccountId === undefined) {
1356
- throw new Error("Empty value provided for input host prefix: AccountId.");
1357
- }
1358
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1359
- if (!__isValidHostname(resolvedHostname)) {
1360
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1361
- }
1362
- }
1363
- b.hn(resolvedHostname);
1364
751
  b.m("GET").h(headers).b(body);
1365
752
  return b.build();
1366
753
  };
@@ -1372,18 +759,6 @@ export const se_GetMultiRegionAccessPointCommand = async (input, context) => {
1372
759
  b.bp("/v20180820/mrap/instances/{Name+}");
1373
760
  b.p("Name", () => input.Name, "{Name+}", true);
1374
761
  let body;
1375
- let { hostname: resolvedHostname } = await context.endpoint();
1376
- if (context.disableHostPrefix !== true) {
1377
- resolvedHostname = "{AccountId}." + resolvedHostname;
1378
- if (input.AccountId === undefined) {
1379
- throw new Error("Empty value provided for input host prefix: AccountId.");
1380
- }
1381
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1382
- if (!__isValidHostname(resolvedHostname)) {
1383
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1384
- }
1385
- }
1386
- b.hn(resolvedHostname);
1387
762
  b.m("GET").h(headers).b(body);
1388
763
  return b.build();
1389
764
  };
@@ -1395,18 +770,6 @@ export const se_GetMultiRegionAccessPointPolicyCommand = async (input, context)
1395
770
  b.bp("/v20180820/mrap/instances/{Name+}/policy");
1396
771
  b.p("Name", () => input.Name, "{Name+}", true);
1397
772
  let body;
1398
- let { hostname: resolvedHostname } = await context.endpoint();
1399
- if (context.disableHostPrefix !== true) {
1400
- resolvedHostname = "{AccountId}." + resolvedHostname;
1401
- if (input.AccountId === undefined) {
1402
- throw new Error("Empty value provided for input host prefix: AccountId.");
1403
- }
1404
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1405
- if (!__isValidHostname(resolvedHostname)) {
1406
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1407
- }
1408
- }
1409
- b.hn(resolvedHostname);
1410
773
  b.m("GET").h(headers).b(body);
1411
774
  return b.build();
1412
775
  };
@@ -1418,18 +781,6 @@ export const se_GetMultiRegionAccessPointPolicyStatusCommand = async (input, con
1418
781
  b.bp("/v20180820/mrap/instances/{Name+}/policystatus");
1419
782
  b.p("Name", () => input.Name, "{Name+}", true);
1420
783
  let body;
1421
- let { hostname: resolvedHostname } = await context.endpoint();
1422
- if (context.disableHostPrefix !== true) {
1423
- resolvedHostname = "{AccountId}." + resolvedHostname;
1424
- if (input.AccountId === undefined) {
1425
- throw new Error("Empty value provided for input host prefix: AccountId.");
1426
- }
1427
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1428
- if (!__isValidHostname(resolvedHostname)) {
1429
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1430
- }
1431
- }
1432
- b.hn(resolvedHostname);
1433
784
  b.m("GET").h(headers).b(body);
1434
785
  return b.build();
1435
786
  };
@@ -1441,18 +792,6 @@ export const se_GetMultiRegionAccessPointRoutesCommand = async (input, context)
1441
792
  b.bp("/v20180820/mrap/instances/{Mrap+}/routes");
1442
793
  b.p("Mrap", () => input.Mrap, "{Mrap+}", true);
1443
794
  let body;
1444
- let { hostname: resolvedHostname } = await context.endpoint();
1445
- if (context.disableHostPrefix !== true) {
1446
- resolvedHostname = "{AccountId}." + resolvedHostname;
1447
- if (input.AccountId === undefined) {
1448
- throw new Error("Empty value provided for input host prefix: AccountId.");
1449
- }
1450
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1451
- if (!__isValidHostname(resolvedHostname)) {
1452
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1453
- }
1454
- }
1455
- b.hn(resolvedHostname);
1456
795
  b.m("GET").h(headers).b(body);
1457
796
  return b.build();
1458
797
  };
@@ -1463,18 +802,6 @@ export const se_GetPublicAccessBlockCommand = async (input, context) => {
1463
802
  });
1464
803
  b.bp("/v20180820/configuration/publicAccessBlock");
1465
804
  let body;
1466
- let { hostname: resolvedHostname } = await context.endpoint();
1467
- if (context.disableHostPrefix !== true) {
1468
- resolvedHostname = "{AccountId}." + resolvedHostname;
1469
- if (input.AccountId === undefined) {
1470
- throw new Error("Empty value provided for input host prefix: AccountId.");
1471
- }
1472
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1473
- if (!__isValidHostname(resolvedHostname)) {
1474
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1475
- }
1476
- }
1477
- b.hn(resolvedHostname);
1478
805
  b.m("GET").h(headers).b(body);
1479
806
  return b.build();
1480
807
  };
@@ -1486,18 +813,6 @@ export const se_GetStorageLensConfigurationCommand = async (input, context) => {
1486
813
  b.bp("/v20180820/storagelens/{ConfigId}");
1487
814
  b.p("ConfigId", () => input.ConfigId, "{ConfigId}", false);
1488
815
  let body;
1489
- let { hostname: resolvedHostname } = await context.endpoint();
1490
- if (context.disableHostPrefix !== true) {
1491
- resolvedHostname = "{AccountId}." + resolvedHostname;
1492
- if (input.AccountId === undefined) {
1493
- throw new Error("Empty value provided for input host prefix: AccountId.");
1494
- }
1495
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1496
- if (!__isValidHostname(resolvedHostname)) {
1497
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1498
- }
1499
- }
1500
- b.hn(resolvedHostname);
1501
816
  b.m("GET").h(headers).b(body);
1502
817
  return b.build();
1503
818
  };
@@ -1509,18 +824,6 @@ export const se_GetStorageLensConfigurationTaggingCommand = async (input, contex
1509
824
  b.bp("/v20180820/storagelens/{ConfigId}/tagging");
1510
825
  b.p("ConfigId", () => input.ConfigId, "{ConfigId}", false);
1511
826
  let body;
1512
- let { hostname: resolvedHostname } = await context.endpoint();
1513
- if (context.disableHostPrefix !== true) {
1514
- resolvedHostname = "{AccountId}." + resolvedHostname;
1515
- if (input.AccountId === undefined) {
1516
- throw new Error("Empty value provided for input host prefix: AccountId.");
1517
- }
1518
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1519
- if (!__isValidHostname(resolvedHostname)) {
1520
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1521
- }
1522
- }
1523
- b.hn(resolvedHostname);
1524
827
  b.m("GET").h(headers).b(body);
1525
828
  return b.build();
1526
829
  };
@@ -1532,18 +835,6 @@ export const se_GetStorageLensGroupCommand = async (input, context) => {
1532
835
  b.bp("/v20180820/storagelensgroup/{Name}");
1533
836
  b.p("Name", () => input.Name, "{Name}", false);
1534
837
  let body;
1535
- let { hostname: resolvedHostname } = await context.endpoint();
1536
- if (context.disableHostPrefix !== true) {
1537
- resolvedHostname = "{AccountId}." + resolvedHostname;
1538
- if (input.AccountId === undefined) {
1539
- throw new Error("Empty value provided for input host prefix: AccountId.");
1540
- }
1541
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1542
- if (!__isValidHostname(resolvedHostname)) {
1543
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1544
- }
1545
- }
1546
- b.hn(resolvedHostname);
1547
838
  b.m("GET").h(headers).b(body);
1548
839
  return b.build();
1549
840
  };
@@ -1563,18 +854,6 @@ export const se_ListAccessGrantsCommand = async (input, context) => {
1563
854
  [_aa]: [, input[_AA]],
1564
855
  });
1565
856
  let body;
1566
- let { hostname: resolvedHostname } = await context.endpoint();
1567
- if (context.disableHostPrefix !== true) {
1568
- resolvedHostname = "{AccountId}." + resolvedHostname;
1569
- if (input.AccountId === undefined) {
1570
- throw new Error("Empty value provided for input host prefix: AccountId.");
1571
- }
1572
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1573
- if (!__isValidHostname(resolvedHostname)) {
1574
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1575
- }
1576
- }
1577
- b.hn(resolvedHostname);
1578
857
  b.m("GET").h(headers).q(query).b(body);
1579
858
  return b.build();
1580
859
  };
@@ -1589,18 +868,6 @@ export const se_ListAccessGrantsInstancesCommand = async (input, context) => {
1589
868
  [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1590
869
  });
1591
870
  let body;
1592
- let { hostname: resolvedHostname } = await context.endpoint();
1593
- if (context.disableHostPrefix !== true) {
1594
- resolvedHostname = "{AccountId}." + resolvedHostname;
1595
- if (input.AccountId === undefined) {
1596
- throw new Error("Empty value provided for input host prefix: AccountId.");
1597
- }
1598
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1599
- if (!__isValidHostname(resolvedHostname)) {
1600
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1601
- }
1602
- }
1603
- b.hn(resolvedHostname);
1604
871
  b.m("GET").h(headers).q(query).b(body);
1605
872
  return b.build();
1606
873
  };
@@ -1616,18 +883,6 @@ export const se_ListAccessGrantsLocationsCommand = async (input, context) => {
1616
883
  [_l]: [, input[_LS]],
1617
884
  });
1618
885
  let body;
1619
- let { hostname: resolvedHostname } = await context.endpoint();
1620
- if (context.disableHostPrefix !== true) {
1621
- resolvedHostname = "{AccountId}." + resolvedHostname;
1622
- if (input.AccountId === undefined) {
1623
- throw new Error("Empty value provided for input host prefix: AccountId.");
1624
- }
1625
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1626
- if (!__isValidHostname(resolvedHostname)) {
1627
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1628
- }
1629
- }
1630
- b.hn(resolvedHostname);
1631
886
  b.m("GET").h(headers).q(query).b(body);
1632
887
  return b.build();
1633
888
  };
@@ -1643,18 +898,6 @@ export const se_ListAccessPointsCommand = async (input, context) => {
1643
898
  [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1644
899
  });
1645
900
  let body;
1646
- let { hostname: resolvedHostname } = await context.endpoint();
1647
- if (context.disableHostPrefix !== true) {
1648
- resolvedHostname = "{AccountId}." + resolvedHostname;
1649
- if (input.AccountId === undefined) {
1650
- throw new Error("Empty value provided for input host prefix: AccountId.");
1651
- }
1652
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1653
- if (!__isValidHostname(resolvedHostname)) {
1654
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1655
- }
1656
- }
1657
- b.hn(resolvedHostname);
1658
901
  b.m("GET").h(headers).q(query).b(body);
1659
902
  return b.build();
1660
903
  };
@@ -1684,18 +927,6 @@ export const se_ListAccessPointsForObjectLambdaCommand = async (input, context)
1684
927
  [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1685
928
  });
1686
929
  let body;
1687
- let { hostname: resolvedHostname } = await context.endpoint();
1688
- if (context.disableHostPrefix !== true) {
1689
- resolvedHostname = "{AccountId}." + resolvedHostname;
1690
- if (input.AccountId === undefined) {
1691
- throw new Error("Empty value provided for input host prefix: AccountId.");
1692
- }
1693
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1694
- if (!__isValidHostname(resolvedHostname)) {
1695
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1696
- }
1697
- }
1698
- b.hn(resolvedHostname);
1699
930
  b.m("GET").h(headers).q(query).b(body);
1700
931
  return b.build();
1701
932
  };
@@ -1712,18 +943,6 @@ export const se_ListCallerAccessGrantsCommand = async (input, context) => {
1712
943
  [_aBA]: [() => input.AllowedByApplication !== void 0, () => input[_ABA].toString()],
1713
944
  });
1714
945
  let body;
1715
- let { hostname: resolvedHostname } = await context.endpoint();
1716
- if (context.disableHostPrefix !== true) {
1717
- resolvedHostname = "{AccountId}." + resolvedHostname;
1718
- if (input.AccountId === undefined) {
1719
- throw new Error("Empty value provided for input host prefix: AccountId.");
1720
- }
1721
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1722
- if (!__isValidHostname(resolvedHostname)) {
1723
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1724
- }
1725
- }
1726
- b.hn(resolvedHostname);
1727
946
  b.m("GET").h(headers).q(query).b(body);
1728
947
  return b.build();
1729
948
  };
@@ -1739,18 +958,6 @@ export const se_ListJobsCommand = async (input, context) => {
1739
958
  [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1740
959
  });
1741
960
  let body;
1742
- let { hostname: resolvedHostname } = await context.endpoint();
1743
- if (context.disableHostPrefix !== true) {
1744
- resolvedHostname = "{AccountId}." + resolvedHostname;
1745
- if (input.AccountId === undefined) {
1746
- throw new Error("Empty value provided for input host prefix: AccountId.");
1747
- }
1748
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1749
- if (!__isValidHostname(resolvedHostname)) {
1750
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1751
- }
1752
- }
1753
- b.hn(resolvedHostname);
1754
961
  b.m("GET").h(headers).q(query).b(body);
1755
962
  return b.build();
1756
963
  };
@@ -1765,18 +972,6 @@ export const se_ListMultiRegionAccessPointsCommand = async (input, context) => {
1765
972
  [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1766
973
  });
1767
974
  let body;
1768
- let { hostname: resolvedHostname } = await context.endpoint();
1769
- if (context.disableHostPrefix !== true) {
1770
- resolvedHostname = "{AccountId}." + resolvedHostname;
1771
- if (input.AccountId === undefined) {
1772
- throw new Error("Empty value provided for input host prefix: AccountId.");
1773
- }
1774
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1775
- if (!__isValidHostname(resolvedHostname)) {
1776
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1777
- }
1778
- }
1779
- b.hn(resolvedHostname);
1780
975
  b.m("GET").h(headers).q(query).b(body);
1781
976
  return b.build();
1782
977
  };
@@ -1792,18 +987,6 @@ export const se_ListRegionalBucketsCommand = async (input, context) => {
1792
987
  [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
1793
988
  });
1794
989
  let body;
1795
- let { hostname: resolvedHostname } = await context.endpoint();
1796
- if (context.disableHostPrefix !== true) {
1797
- resolvedHostname = "{AccountId}." + resolvedHostname;
1798
- if (input.AccountId === undefined) {
1799
- throw new Error("Empty value provided for input host prefix: AccountId.");
1800
- }
1801
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1802
- if (!__isValidHostname(resolvedHostname)) {
1803
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1804
- }
1805
- }
1806
- b.hn(resolvedHostname);
1807
990
  b.m("GET").h(headers).q(query).b(body);
1808
991
  return b.build();
1809
992
  };
@@ -1817,18 +1000,6 @@ export const se_ListStorageLensConfigurationsCommand = async (input, context) =>
1817
1000
  [_nT]: [, input[_NT]],
1818
1001
  });
1819
1002
  let body;
1820
- let { hostname: resolvedHostname } = await context.endpoint();
1821
- if (context.disableHostPrefix !== true) {
1822
- resolvedHostname = "{AccountId}." + resolvedHostname;
1823
- if (input.AccountId === undefined) {
1824
- throw new Error("Empty value provided for input host prefix: AccountId.");
1825
- }
1826
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1827
- if (!__isValidHostname(resolvedHostname)) {
1828
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1829
- }
1830
- }
1831
- b.hn(resolvedHostname);
1832
1003
  b.m("GET").h(headers).q(query).b(body);
1833
1004
  return b.build();
1834
1005
  };
@@ -1842,18 +1013,6 @@ export const se_ListStorageLensGroupsCommand = async (input, context) => {
1842
1013
  [_nT]: [, input[_NT]],
1843
1014
  });
1844
1015
  let body;
1845
- let { hostname: resolvedHostname } = await context.endpoint();
1846
- if (context.disableHostPrefix !== true) {
1847
- resolvedHostname = "{AccountId}." + resolvedHostname;
1848
- if (input.AccountId === undefined) {
1849
- throw new Error("Empty value provided for input host prefix: AccountId.");
1850
- }
1851
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1852
- if (!__isValidHostname(resolvedHostname)) {
1853
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1854
- }
1855
- }
1856
- b.hn(resolvedHostname);
1857
1016
  b.m("GET").h(headers).q(query).b(body);
1858
1017
  return b.build();
1859
1018
  };
@@ -1865,18 +1024,6 @@ export const se_ListTagsForResourceCommand = async (input, context) => {
1865
1024
  b.bp("/v20180820/tags/{ResourceArn+}");
1866
1025
  b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn+}", true);
1867
1026
  let body;
1868
- let { hostname: resolvedHostname } = await context.endpoint();
1869
- if (context.disableHostPrefix !== true) {
1870
- resolvedHostname = "{AccountId}." + resolvedHostname;
1871
- if (input.AccountId === undefined) {
1872
- throw new Error("Empty value provided for input host prefix: AccountId.");
1873
- }
1874
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1875
- if (!__isValidHostname(resolvedHostname)) {
1876
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1877
- }
1878
- }
1879
- b.hn(resolvedHostname);
1880
1027
  b.m("GET").h(headers).b(body);
1881
1028
  return b.build();
1882
1029
  };
@@ -1896,18 +1043,6 @@ export const se_PutAccessGrantsInstanceResourcePolicyCommand = async (input, con
1896
1043
  bn.c(__XmlNode.of(_PD, input[_Po]).n(_Po));
1897
1044
  }
1898
1045
  body += bn.toString();
1899
- let { hostname: resolvedHostname } = await context.endpoint();
1900
- if (context.disableHostPrefix !== true) {
1901
- resolvedHostname = "{AccountId}." + resolvedHostname;
1902
- if (input.AccountId === undefined) {
1903
- throw new Error("Empty value provided for input host prefix: AccountId.");
1904
- }
1905
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1906
- if (!__isValidHostname(resolvedHostname)) {
1907
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1908
- }
1909
- }
1910
- b.hn(resolvedHostname);
1911
1046
  b.m("PUT").h(headers).b(body);
1912
1047
  return b.build();
1913
1048
  };
@@ -1927,18 +1062,6 @@ export const se_PutAccessPointConfigurationForObjectLambdaCommand = async (input
1927
1062
  bn.c(se_ObjectLambdaConfiguration(input[_C], context).n(_C));
1928
1063
  }
1929
1064
  body += bn.toString();
1930
- let { hostname: resolvedHostname } = await context.endpoint();
1931
- if (context.disableHostPrefix !== true) {
1932
- resolvedHostname = "{AccountId}." + resolvedHostname;
1933
- if (input.AccountId === undefined) {
1934
- throw new Error("Empty value provided for input host prefix: AccountId.");
1935
- }
1936
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1937
- if (!__isValidHostname(resolvedHostname)) {
1938
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1939
- }
1940
- }
1941
- b.hn(resolvedHostname);
1942
1065
  b.m("PUT").h(headers).b(body);
1943
1066
  return b.build();
1944
1067
  };
@@ -1956,18 +1079,6 @@ export const se_PutAccessPointPolicyCommand = async (input, context) => {
1956
1079
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
1957
1080
  bn.cc(input, _Po);
1958
1081
  body += bn.toString();
1959
- let { hostname: resolvedHostname } = await context.endpoint();
1960
- if (context.disableHostPrefix !== true) {
1961
- resolvedHostname = "{AccountId}." + resolvedHostname;
1962
- if (input.AccountId === undefined) {
1963
- throw new Error("Empty value provided for input host prefix: AccountId.");
1964
- }
1965
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1966
- if (!__isValidHostname(resolvedHostname)) {
1967
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1968
- }
1969
- }
1970
- b.hn(resolvedHostname);
1971
1082
  b.m("PUT").h(headers).b(body);
1972
1083
  return b.build();
1973
1084
  };
@@ -1987,18 +1098,6 @@ export const se_PutAccessPointPolicyForObjectLambdaCommand = async (input, conte
1987
1098
  bn.c(__XmlNode.of(_OLP, input[_Po]).n(_Po));
1988
1099
  }
1989
1100
  body += bn.toString();
1990
- let { hostname: resolvedHostname } = await context.endpoint();
1991
- if (context.disableHostPrefix !== true) {
1992
- resolvedHostname = "{AccountId}." + resolvedHostname;
1993
- if (input.AccountId === undefined) {
1994
- throw new Error("Empty value provided for input host prefix: AccountId.");
1995
- }
1996
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
1997
- if (!__isValidHostname(resolvedHostname)) {
1998
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
1999
- }
2000
- }
2001
- b.hn(resolvedHostname);
2002
1101
  b.m("PUT").h(headers).b(body);
2003
1102
  return b.build();
2004
1103
  };
@@ -2037,18 +1136,6 @@ export const se_PutBucketLifecycleConfigurationCommand = async (input, context)
2037
1136
  contents.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
2038
1137
  body += contents.toString();
2039
1138
  }
2040
- let { hostname: resolvedHostname } = await context.endpoint();
2041
- if (context.disableHostPrefix !== true) {
2042
- resolvedHostname = "{AccountId}." + resolvedHostname;
2043
- if (input.AccountId === undefined) {
2044
- throw new Error("Empty value provided for input host prefix: AccountId.");
2045
- }
2046
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2047
- if (!__isValidHostname(resolvedHostname)) {
2048
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2049
- }
2050
- }
2051
- b.hn(resolvedHostname);
2052
1139
  b.m("PUT").h(headers).b(body);
2053
1140
  return b.build();
2054
1141
  };
@@ -2067,18 +1154,6 @@ export const se_PutBucketPolicyCommand = async (input, context) => {
2067
1154
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
2068
1155
  bn.cc(input, _Po);
2069
1156
  body += bn.toString();
2070
- let { hostname: resolvedHostname } = await context.endpoint();
2071
- if (context.disableHostPrefix !== true) {
2072
- resolvedHostname = "{AccountId}." + resolvedHostname;
2073
- if (input.AccountId === undefined) {
2074
- throw new Error("Empty value provided for input host prefix: AccountId.");
2075
- }
2076
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2077
- if (!__isValidHostname(resolvedHostname)) {
2078
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2079
- }
2080
- }
2081
- b.hn(resolvedHostname);
2082
1157
  b.m("PUT").h(headers).b(body);
2083
1158
  return b.build();
2084
1159
  };
@@ -2098,18 +1173,6 @@ export const se_PutBucketReplicationCommand = async (input, context) => {
2098
1173
  contents.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
2099
1174
  body += contents.toString();
2100
1175
  }
2101
- let { hostname: resolvedHostname } = await context.endpoint();
2102
- if (context.disableHostPrefix !== true) {
2103
- resolvedHostname = "{AccountId}." + resolvedHostname;
2104
- if (input.AccountId === undefined) {
2105
- throw new Error("Empty value provided for input host prefix: AccountId.");
2106
- }
2107
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2108
- if (!__isValidHostname(resolvedHostname)) {
2109
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2110
- }
2111
- }
2112
- b.hn(resolvedHostname);
2113
1176
  b.m("PUT").h(headers).b(body);
2114
1177
  return b.build();
2115
1178
  };
@@ -2129,18 +1192,6 @@ export const se_PutBucketTaggingCommand = async (input, context) => {
2129
1192
  contents.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
2130
1193
  body += contents.toString();
2131
1194
  }
2132
- let { hostname: resolvedHostname } = await context.endpoint();
2133
- if (context.disableHostPrefix !== true) {
2134
- resolvedHostname = "{AccountId}." + resolvedHostname;
2135
- if (input.AccountId === undefined) {
2136
- throw new Error("Empty value provided for input host prefix: AccountId.");
2137
- }
2138
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2139
- if (!__isValidHostname(resolvedHostname)) {
2140
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2141
- }
2142
- }
2143
- b.hn(resolvedHostname);
2144
1195
  b.m("PUT").h(headers).b(body);
2145
1196
  return b.build();
2146
1197
  };
@@ -2161,18 +1212,6 @@ export const se_PutBucketVersioningCommand = async (input, context) => {
2161
1212
  contents.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
2162
1213
  body += contents.toString();
2163
1214
  }
2164
- let { hostname: resolvedHostname } = await context.endpoint();
2165
- if (context.disableHostPrefix !== true) {
2166
- resolvedHostname = "{AccountId}." + resolvedHostname;
2167
- if (input.AccountId === undefined) {
2168
- throw new Error("Empty value provided for input host prefix: AccountId.");
2169
- }
2170
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2171
- if (!__isValidHostname(resolvedHostname)) {
2172
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2173
- }
2174
- }
2175
- b.hn(resolvedHostname);
2176
1215
  b.m("PUT").h(headers).b(body);
2177
1216
  return b.build();
2178
1217
  };
@@ -2190,18 +1229,6 @@ export const se_PutJobTaggingCommand = async (input, context) => {
2190
1229
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
2191
1230
  bn.lc(input, "Tags", "Tags", () => se_S3TagSet(input[_T], context));
2192
1231
  body += bn.toString();
2193
- let { hostname: resolvedHostname } = await context.endpoint();
2194
- if (context.disableHostPrefix !== true) {
2195
- resolvedHostname = "{AccountId}." + resolvedHostname;
2196
- if (input.AccountId === undefined) {
2197
- throw new Error("Empty value provided for input host prefix: AccountId.");
2198
- }
2199
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2200
- if (!__isValidHostname(resolvedHostname)) {
2201
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2202
- }
2203
- }
2204
- b.hn(resolvedHostname);
2205
1232
  b.m("PUT").h(headers).b(body);
2206
1233
  return b.build();
2207
1234
  };
@@ -2226,18 +1253,6 @@ export const se_PutMultiRegionAccessPointPolicyCommand = async (input, context)
2226
1253
  bn.c(se_PutMultiRegionAccessPointPolicyInput(input[_De], context).n(_De));
2227
1254
  }
2228
1255
  body += bn.toString();
2229
- let { hostname: resolvedHostname } = await context.endpoint();
2230
- if (context.disableHostPrefix !== true) {
2231
- resolvedHostname = "{AccountId}." + resolvedHostname;
2232
- if (input.AccountId === undefined) {
2233
- throw new Error("Empty value provided for input host prefix: AccountId.");
2234
- }
2235
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2236
- if (!__isValidHostname(resolvedHostname)) {
2237
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2238
- }
2239
- }
2240
- b.hn(resolvedHostname);
2241
1256
  b.m("POST").h(headers).b(body);
2242
1257
  return b.build();
2243
1258
  };
@@ -2256,18 +1271,6 @@ export const se_PutPublicAccessBlockCommand = async (input, context) => {
2256
1271
  contents.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
2257
1272
  body += contents.toString();
2258
1273
  }
2259
- let { hostname: resolvedHostname } = await context.endpoint();
2260
- if (context.disableHostPrefix !== true) {
2261
- resolvedHostname = "{AccountId}." + resolvedHostname;
2262
- if (input.AccountId === undefined) {
2263
- throw new Error("Empty value provided for input host prefix: AccountId.");
2264
- }
2265
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2266
- if (!__isValidHostname(resolvedHostname)) {
2267
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2268
- }
2269
- }
2270
- b.hn(resolvedHostname);
2271
1274
  b.m("PUT").h(headers).b(body);
2272
1275
  return b.build();
2273
1276
  };
@@ -2288,18 +1291,6 @@ export const se_PutStorageLensConfigurationCommand = async (input, context) => {
2288
1291
  }
2289
1292
  bn.lc(input, "Tags", "Tags", () => se_StorageLensTags(input[_T], context));
2290
1293
  body += bn.toString();
2291
- let { hostname: resolvedHostname } = await context.endpoint();
2292
- if (context.disableHostPrefix !== true) {
2293
- resolvedHostname = "{AccountId}." + resolvedHostname;
2294
- if (input.AccountId === undefined) {
2295
- throw new Error("Empty value provided for input host prefix: AccountId.");
2296
- }
2297
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2298
- if (!__isValidHostname(resolvedHostname)) {
2299
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2300
- }
2301
- }
2302
- b.hn(resolvedHostname);
2303
1294
  b.m("PUT").h(headers).b(body);
2304
1295
  return b.build();
2305
1296
  };
@@ -2317,18 +1308,6 @@ export const se_PutStorageLensConfigurationTaggingCommand = async (input, contex
2317
1308
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
2318
1309
  bn.lc(input, "Tags", "Tags", () => se_StorageLensTags(input[_T], context));
2319
1310
  body += bn.toString();
2320
- let { hostname: resolvedHostname } = await context.endpoint();
2321
- if (context.disableHostPrefix !== true) {
2322
- resolvedHostname = "{AccountId}." + resolvedHostname;
2323
- if (input.AccountId === undefined) {
2324
- throw new Error("Empty value provided for input host prefix: AccountId.");
2325
- }
2326
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2327
- if (!__isValidHostname(resolvedHostname)) {
2328
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2329
- }
2330
- }
2331
- b.hn(resolvedHostname);
2332
1311
  b.m("PUT").h(headers).b(body);
2333
1312
  return b.build();
2334
1313
  };
@@ -2346,18 +1325,6 @@ export const se_SubmitMultiRegionAccessPointRoutesCommand = async (input, contex
2346
1325
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
2347
1326
  bn.lc(input, "RouteUpdates", "RouteUpdates", () => se_RouteList(input[_RU], context));
2348
1327
  body += bn.toString();
2349
- let { hostname: resolvedHostname } = await context.endpoint();
2350
- if (context.disableHostPrefix !== true) {
2351
- resolvedHostname = "{AccountId}." + resolvedHostname;
2352
- if (input.AccountId === undefined) {
2353
- throw new Error("Empty value provided for input host prefix: AccountId.");
2354
- }
2355
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2356
- if (!__isValidHostname(resolvedHostname)) {
2357
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2358
- }
2359
- }
2360
- b.hn(resolvedHostname);
2361
1328
  b.m("PATCH").h(headers).b(body);
2362
1329
  return b.build();
2363
1330
  };
@@ -2375,18 +1342,6 @@ export const se_TagResourceCommand = async (input, context) => {
2375
1342
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
2376
1343
  bn.lc(input, "Tags", "Tags", () => se_TagList(input[_T], context));
2377
1344
  body += bn.toString();
2378
- let { hostname: resolvedHostname } = await context.endpoint();
2379
- if (context.disableHostPrefix !== true) {
2380
- resolvedHostname = "{AccountId}." + resolvedHostname;
2381
- if (input.AccountId === undefined) {
2382
- throw new Error("Empty value provided for input host prefix: AccountId.");
2383
- }
2384
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2385
- if (!__isValidHostname(resolvedHostname)) {
2386
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2387
- }
2388
- }
2389
- b.hn(resolvedHostname);
2390
1345
  b.m("POST").h(headers).b(body);
2391
1346
  return b.build();
2392
1347
  };
@@ -2401,18 +1356,6 @@ export const se_UntagResourceCommand = async (input, context) => {
2401
1356
  [_tK]: [__expectNonNull(input.TagKeys, `TagKeys`) != null, () => input[_TK] || []],
2402
1357
  });
2403
1358
  let body;
2404
- let { hostname: resolvedHostname } = await context.endpoint();
2405
- if (context.disableHostPrefix !== true) {
2406
- resolvedHostname = "{AccountId}." + resolvedHostname;
2407
- if (input.AccountId === undefined) {
2408
- throw new Error("Empty value provided for input host prefix: AccountId.");
2409
- }
2410
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2411
- if (!__isValidHostname(resolvedHostname)) {
2412
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2413
- }
2414
- }
2415
- b.hn(resolvedHostname);
2416
1359
  b.m("DELETE").h(headers).q(query).b(body);
2417
1360
  return b.build();
2418
1361
  };
@@ -2430,18 +1373,6 @@ export const se_UpdateAccessGrantsLocationCommand = async (input, context) => {
2430
1373
  bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
2431
1374
  bn.cc(input, _IAMRA);
2432
1375
  body += bn.toString();
2433
- let { hostname: resolvedHostname } = await context.endpoint();
2434
- if (context.disableHostPrefix !== true) {
2435
- resolvedHostname = "{AccountId}." + resolvedHostname;
2436
- if (input.AccountId === undefined) {
2437
- throw new Error("Empty value provided for input host prefix: AccountId.");
2438
- }
2439
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2440
- if (!__isValidHostname(resolvedHostname)) {
2441
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2442
- }
2443
- }
2444
- b.hn(resolvedHostname);
2445
1376
  b.m("PUT").h(headers).b(body);
2446
1377
  return b.build();
2447
1378
  };
@@ -2456,18 +1387,6 @@ export const se_UpdateJobPriorityCommand = async (input, context) => {
2456
1387
  [_pri]: [__expectNonNull(input.Priority, `Priority`) != null, () => input[_Pr].toString()],
2457
1388
  });
2458
1389
  let body;
2459
- let { hostname: resolvedHostname } = await context.endpoint();
2460
- if (context.disableHostPrefix !== true) {
2461
- resolvedHostname = "{AccountId}." + resolvedHostname;
2462
- if (input.AccountId === undefined) {
2463
- throw new Error("Empty value provided for input host prefix: AccountId.");
2464
- }
2465
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2466
- if (!__isValidHostname(resolvedHostname)) {
2467
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2468
- }
2469
- }
2470
- b.hn(resolvedHostname);
2471
1390
  b.m("POST").h(headers).q(query).b(body);
2472
1391
  return b.build();
2473
1392
  };
@@ -2483,18 +1402,6 @@ export const se_UpdateJobStatusCommand = async (input, context) => {
2483
1402
  [_sUR]: [, input[_SUR]],
2484
1403
  });
2485
1404
  let body;
2486
- let { hostname: resolvedHostname } = await context.endpoint();
2487
- if (context.disableHostPrefix !== true) {
2488
- resolvedHostname = "{AccountId}." + resolvedHostname;
2489
- if (input.AccountId === undefined) {
2490
- throw new Error("Empty value provided for input host prefix: AccountId.");
2491
- }
2492
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2493
- if (!__isValidHostname(resolvedHostname)) {
2494
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2495
- }
2496
- }
2497
- b.hn(resolvedHostname);
2498
1405
  b.m("POST").h(headers).q(query).b(body);
2499
1406
  return b.build();
2500
1407
  };
@@ -2514,18 +1421,6 @@ export const se_UpdateStorageLensGroupCommand = async (input, context) => {
2514
1421
  bn.c(se_StorageLensGroup(input[_SLG], context).n(_SLG));
2515
1422
  }
2516
1423
  body += bn.toString();
2517
- let { hostname: resolvedHostname } = await context.endpoint();
2518
- if (context.disableHostPrefix !== true) {
2519
- resolvedHostname = "{AccountId}." + resolvedHostname;
2520
- if (input.AccountId === undefined) {
2521
- throw new Error("Empty value provided for input host prefix: AccountId.");
2522
- }
2523
- resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
2524
- if (!__isValidHostname(resolvedHostname)) {
2525
- throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
2526
- }
2527
- }
2528
- b.hn(resolvedHostname);
2529
1424
  b.m("PUT").h(headers).b(body);
2530
1425
  return b.build();
2531
1426
  };