@aws-sdk/client-s3 3.310.0 → 3.315.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/protocols/Aws_restXml.js +373 -466
  2. package/dist-es/protocols/Aws_restXml.js +95 -188
  3. package/package.json +6 -6
package/dist-cjs/protocols/Aws_restXml.js CHANGED
@@ -13,14 +13,14 @@ const models_1_1 = require("../models/models_1");
13
13
  const S3ServiceException_1 = require("../models/S3ServiceException");
14
14
  const se_AbortMultipartUploadCommand = async (input, context) => {
15
15
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
16
- const headers = map({}, isSerializableHeaderValue, {
16
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
17
17
  "x-amz-request-payer": input.RequestPayer,
18
18
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
19
19
  });
20
20
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
21
21
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
22
22
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
23
- const query = map({
23
+ const query = (0, smithy_client_1.map)({
24
24
  "x-id": [, "AbortMultipartUpload"],
25
25
  uploadId: [, (0, smithy_client_1.expectNonNull)(input.UploadId, `UploadId`)],
26
26
  });
@@ -39,7 +39,7 @@ const se_AbortMultipartUploadCommand = async (input, context) => {
39
39
  exports.se_AbortMultipartUploadCommand = se_AbortMultipartUploadCommand;
40
40
  const se_CompleteMultipartUploadCommand = async (input, context) => {
41
41
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
42
- const headers = map({}, isSerializableHeaderValue, {
42
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
43
43
  "content-type": "application/xml",
44
44
  "x-amz-checksum-crc32": input.ChecksumCRC32,
45
45
  "x-amz-checksum-crc32c": input.ChecksumCRC32C,
@@ -54,7 +54,7 @@ const se_CompleteMultipartUploadCommand = async (input, context) => {
54
54
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
55
55
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
56
56
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
57
- const query = map({
57
+ const query = (0, smithy_client_1.map)({
58
58
  "x-id": [, "CompleteMultipartUpload"],
59
59
  uploadId: [, (0, smithy_client_1.expectNonNull)(input.UploadId, `UploadId`)],
60
60
  });
@@ -84,7 +84,7 @@ const se_CompleteMultipartUploadCommand = async (input, context) => {
84
84
  exports.se_CompleteMultipartUploadCommand = se_CompleteMultipartUploadCommand;
85
85
  const se_CopyObjectCommand = async (input, context) => {
86
86
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
87
- const headers = map({}, isSerializableHeaderValue, {
87
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
88
88
  "x-amz-acl": input.ACL,
89
89
  "cache-control": input.CacheControl,
90
90
  "x-amz-checksum-algorithm": input.ChecksumAlgorithm,
@@ -144,7 +144,7 @@ const se_CopyObjectCommand = async (input, context) => {
144
144
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
145
145
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
146
146
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
147
- const query = map({
147
+ const query = (0, smithy_client_1.map)({
148
148
  "x-id": [, "CopyObject"],
149
149
  });
150
150
  let body;
@@ -162,7 +162,7 @@ const se_CopyObjectCommand = async (input, context) => {
162
162
  exports.se_CopyObjectCommand = se_CopyObjectCommand;
163
163
  const se_CreateBucketCommand = async (input, context) => {
164
164
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
165
- const headers = map({}, isSerializableHeaderValue, {
165
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
166
166
  "content-type": "application/xml",
167
167
  "x-amz-acl": input.ACL,
168
168
  "x-amz-grant-full-control": input.GrantFullControl,
@@ -202,7 +202,7 @@ const se_CreateBucketCommand = async (input, context) => {
202
202
  exports.se_CreateBucketCommand = se_CreateBucketCommand;
203
203
  const se_CreateMultipartUploadCommand = async (input, context) => {
204
204
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
205
- const headers = map({}, isSerializableHeaderValue, {
205
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
206
206
  "x-amz-acl": input.ACL,
207
207
  "cache-control": input.CacheControl,
208
208
  "content-disposition": input.ContentDisposition,
@@ -245,7 +245,7 @@ const se_CreateMultipartUploadCommand = async (input, context) => {
245
245
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
246
246
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
247
247
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
248
- const query = map({
248
+ const query = (0, smithy_client_1.map)({
249
249
  uploads: [, ""],
250
250
  "x-id": [, "CreateMultipartUpload"],
251
251
  });
@@ -264,7 +264,7 @@ const se_CreateMultipartUploadCommand = async (input, context) => {
264
264
  exports.se_CreateMultipartUploadCommand = se_CreateMultipartUploadCommand;
265
265
  const se_DeleteBucketCommand = async (input, context) => {
266
266
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
267
- const headers = map({}, isSerializableHeaderValue, {
267
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
268
268
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
269
269
  });
270
270
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
@@ -283,12 +283,12 @@ const se_DeleteBucketCommand = async (input, context) => {
283
283
  exports.se_DeleteBucketCommand = se_DeleteBucketCommand;
284
284
  const se_DeleteBucketAnalyticsConfigurationCommand = async (input, context) => {
285
285
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
286
- const headers = map({}, isSerializableHeaderValue, {
286
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
287
287
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
288
288
  });
289
289
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
290
290
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
291
- const query = map({
291
+ const query = (0, smithy_client_1.map)({
292
292
  analytics: [, ""],
293
293
  id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)],
294
294
  });
@@ -307,12 +307,12 @@ const se_DeleteBucketAnalyticsConfigurationCommand = async (input, context) => {
307
307
  exports.se_DeleteBucketAnalyticsConfigurationCommand = se_DeleteBucketAnalyticsConfigurationCommand;
308
308
  const se_DeleteBucketCorsCommand = async (input, context) => {
309
309
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
310
- const headers = map({}, isSerializableHeaderValue, {
310
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
311
311
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
312
312
  });
313
313
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
314
314
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
315
- const query = map({
315
+ const query = (0, smithy_client_1.map)({
316
316
  cors: [, ""],
317
317
  });
318
318
  let body;
@@ -330,12 +330,12 @@ const se_DeleteBucketCorsCommand = async (input, context) => {
330
330
  exports.se_DeleteBucketCorsCommand = se_DeleteBucketCorsCommand;
331
331
  const se_DeleteBucketEncryptionCommand = async (input, context) => {
332
332
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
333
- const headers = map({}, isSerializableHeaderValue, {
333
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
334
334
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
335
335
  });
336
336
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
337
337
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
338
- const query = map({
338
+ const query = (0, smithy_client_1.map)({
339
339
  encryption: [, ""],
340
340
  });
341
341
  let body;
@@ -356,7 +356,7 @@ const se_DeleteBucketIntelligentTieringConfigurationCommand = async (input, cont
356
356
  const headers = {};
357
357
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
358
358
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
359
- const query = map({
359
+ const query = (0, smithy_client_1.map)({
360
360
  "intelligent-tiering": [, ""],
361
361
  id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)],
362
362
  });
@@ -375,12 +375,12 @@ const se_DeleteBucketIntelligentTieringConfigurationCommand = async (input, cont
375
375
  exports.se_DeleteBucketIntelligentTieringConfigurationCommand = se_DeleteBucketIntelligentTieringConfigurationCommand;
376
376
  const se_DeleteBucketInventoryConfigurationCommand = async (input, context) => {
377
377
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
378
- const headers = map({}, isSerializableHeaderValue, {
378
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
379
379
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
380
380
  });
381
381
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
382
382
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
383
- const query = map({
383
+ const query = (0, smithy_client_1.map)({
384
384
  inventory: [, ""],
385
385
  id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)],
386
386
  });
@@ -399,12 +399,12 @@ const se_DeleteBucketInventoryConfigurationCommand = async (input, context) => {
399
399
  exports.se_DeleteBucketInventoryConfigurationCommand = se_DeleteBucketInventoryConfigurationCommand;
400
400
  const se_DeleteBucketLifecycleCommand = async (input, context) => {
401
401
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
402
- const headers = map({}, isSerializableHeaderValue, {
402
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
403
403
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
404
404
  });
405
405
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
406
406
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
407
- const query = map({
407
+ const query = (0, smithy_client_1.map)({
408
408
  lifecycle: [, ""],
409
409
  });
410
410
  let body;
@@ -422,12 +422,12 @@ const se_DeleteBucketLifecycleCommand = async (input, context) => {
422
422
  exports.se_DeleteBucketLifecycleCommand = se_DeleteBucketLifecycleCommand;
423
423
  const se_DeleteBucketMetricsConfigurationCommand = async (input, context) => {
424
424
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
425
- const headers = map({}, isSerializableHeaderValue, {
425
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
426
426
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
427
427
  });
428
428
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
429
429
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
430
- const query = map({
430
+ const query = (0, smithy_client_1.map)({
431
431
  metrics: [, ""],
432
432
  id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)],
433
433
  });
@@ -446,12 +446,12 @@ const se_DeleteBucketMetricsConfigurationCommand = async (input, context) => {
446
446
  exports.se_DeleteBucketMetricsConfigurationCommand = se_DeleteBucketMetricsConfigurationCommand;
447
447
  const se_DeleteBucketOwnershipControlsCommand = async (input, context) => {
448
448
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
449
- const headers = map({}, isSerializableHeaderValue, {
449
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
450
450
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
451
451
  });
452
452
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
453
453
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
454
- const query = map({
454
+ const query = (0, smithy_client_1.map)({
455
455
  ownershipControls: [, ""],
456
456
  });
457
457
  let body;
@@ -469,12 +469,12 @@ const se_DeleteBucketOwnershipControlsCommand = async (input, context) => {
469
469
  exports.se_DeleteBucketOwnershipControlsCommand = se_DeleteBucketOwnershipControlsCommand;
470
470
  const se_DeleteBucketPolicyCommand = async (input, context) => {
471
471
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
472
- const headers = map({}, isSerializableHeaderValue, {
472
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
473
473
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
474
474
  });
475
475
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
476
476
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
477
- const query = map({
477
+ const query = (0, smithy_client_1.map)({
478
478
  policy: [, ""],
479
479
  });
480
480
  let body;
@@ -492,12 +492,12 @@ const se_DeleteBucketPolicyCommand = async (input, context) => {
492
492
  exports.se_DeleteBucketPolicyCommand = se_DeleteBucketPolicyCommand;
493
493
  const se_DeleteBucketReplicationCommand = async (input, context) => {
494
494
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
495
- const headers = map({}, isSerializableHeaderValue, {
495
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
496
496
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
497
497
  });
498
498
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
499
499
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
500
- const query = map({
500
+ const query = (0, smithy_client_1.map)({
501
501
  replication: [, ""],
502
502
  });
503
503
  let body;
@@ -515,12 +515,12 @@ const se_DeleteBucketReplicationCommand = async (input, context) => {
515
515
  exports.se_DeleteBucketReplicationCommand = se_DeleteBucketReplicationCommand;
516
516
  const se_DeleteBucketTaggingCommand = async (input, context) => {
517
517
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
518
- const headers = map({}, isSerializableHeaderValue, {
518
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
519
519
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
520
520
  });
521
521
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
522
522
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
523
- const query = map({
523
+ const query = (0, smithy_client_1.map)({
524
524
  tagging: [, ""],
525
525
  });
526
526
  let body;
@@ -538,12 +538,12 @@ const se_DeleteBucketTaggingCommand = async (input, context) => {
538
538
  exports.se_DeleteBucketTaggingCommand = se_DeleteBucketTaggingCommand;
539
539
  const se_DeleteBucketWebsiteCommand = async (input, context) => {
540
540
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
541
- const headers = map({}, isSerializableHeaderValue, {
541
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
542
542
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
543
543
  });
544
544
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
545
545
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
546
- const query = map({
546
+ const query = (0, smithy_client_1.map)({
547
547
  website: [, ""],
548
548
  });
549
549
  let body;
@@ -561,7 +561,7 @@ const se_DeleteBucketWebsiteCommand = async (input, context) => {
561
561
  exports.se_DeleteBucketWebsiteCommand = se_DeleteBucketWebsiteCommand;
562
562
  const se_DeleteObjectCommand = async (input, context) => {
563
563
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
564
- const headers = map({}, isSerializableHeaderValue, {
564
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
565
565
  "x-amz-mfa": input.MFA,
566
566
  "x-amz-request-payer": input.RequestPayer,
567
567
  "x-amz-bypass-governance-retention": [
@@ -573,7 +573,7 @@ const se_DeleteObjectCommand = async (input, context) => {
573
573
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
574
574
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
575
575
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
576
- const query = map({
576
+ const query = (0, smithy_client_1.map)({
577
577
  "x-id": [, "DeleteObject"],
578
578
  versionId: [, input.VersionId],
579
579
  });
@@ -592,7 +592,7 @@ const se_DeleteObjectCommand = async (input, context) => {
592
592
  exports.se_DeleteObjectCommand = se_DeleteObjectCommand;
593
593
  const se_DeleteObjectsCommand = async (input, context) => {
594
594
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
595
- const headers = map({}, isSerializableHeaderValue, {
595
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
596
596
  "content-type": "application/xml",
597
597
  "x-amz-mfa": input.MFA,
598
598
  "x-amz-request-payer": input.RequestPayer,
@@ -605,7 +605,7 @@ const se_DeleteObjectsCommand = async (input, context) => {
605
605
  });
606
606
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
607
607
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
608
- const query = map({
608
+ const query = (0, smithy_client_1.map)({
609
609
  delete: [, ""],
610
610
  "x-id": [, "DeleteObjects"],
611
611
  });
@@ -634,13 +634,13 @@ const se_DeleteObjectsCommand = async (input, context) => {
634
634
  exports.se_DeleteObjectsCommand = se_DeleteObjectsCommand;
635
635
  const se_DeleteObjectTaggingCommand = async (input, context) => {
636
636
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
637
- const headers = map({}, isSerializableHeaderValue, {
637
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
638
638
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
639
639
  });
640
640
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
641
641
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
642
642
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
643
- const query = map({
643
+ const query = (0, smithy_client_1.map)({
644
644
  tagging: [, ""],
645
645
  versionId: [, input.VersionId],
646
646
  });
@@ -659,12 +659,12 @@ const se_DeleteObjectTaggingCommand = async (input, context) => {
659
659
  exports.se_DeleteObjectTaggingCommand = se_DeleteObjectTaggingCommand;
660
660
  const se_DeletePublicAccessBlockCommand = async (input, context) => {
661
661
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
662
- const headers = map({}, isSerializableHeaderValue, {
662
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
663
663
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
664
664
  });
665
665
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
666
666
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
667
- const query = map({
667
+ const query = (0, smithy_client_1.map)({
668
668
  publicAccessBlock: [, ""],
669
669
  });
670
670
  let body;
@@ -682,12 +682,12 @@ const se_DeletePublicAccessBlockCommand = async (input, context) => {
682
682
  exports.se_DeletePublicAccessBlockCommand = se_DeletePublicAccessBlockCommand;
683
683
  const se_GetBucketAccelerateConfigurationCommand = async (input, context) => {
684
684
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
685
- const headers = map({}, isSerializableHeaderValue, {
685
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
686
686
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
687
687
  });
688
688
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
689
689
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
690
- const query = map({
690
+ const query = (0, smithy_client_1.map)({
691
691
  accelerate: [, ""],
692
692
  });
693
693
  let body;
@@ -705,12 +705,12 @@ const se_GetBucketAccelerateConfigurationCommand = async (input, context) => {
705
705
  exports.se_GetBucketAccelerateConfigurationCommand = se_GetBucketAccelerateConfigurationCommand;
706
706
  const se_GetBucketAclCommand = async (input, context) => {
707
707
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
708
- const headers = map({}, isSerializableHeaderValue, {
708
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
709
709
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
710
710
  });
711
711
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
712
712
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
713
- const query = map({
713
+ const query = (0, smithy_client_1.map)({
714
714
  acl: [, ""],
715
715
  });
716
716
  let body;
@@ -728,12 +728,12 @@ const se_GetBucketAclCommand = async (input, context) => {
728
728
  exports.se_GetBucketAclCommand = se_GetBucketAclCommand;
729
729
  const se_GetBucketAnalyticsConfigurationCommand = async (input, context) => {
730
730
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
731
- const headers = map({}, isSerializableHeaderValue, {
731
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
732
732
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
733
733
  });
734
734
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
735
735
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
736
- const query = map({
736
+ const query = (0, smithy_client_1.map)({
737
737
  analytics: [, ""],
738
738
  "x-id": [, "GetBucketAnalyticsConfiguration"],
739
739
  id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)],
@@ -753,12 +753,12 @@ const se_GetBucketAnalyticsConfigurationCommand = async (input, context) => {
753
753
  exports.se_GetBucketAnalyticsConfigurationCommand = se_GetBucketAnalyticsConfigurationCommand;
754
754
  const se_GetBucketCorsCommand = async (input, context) => {
755
755
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
756
- const headers = map({}, isSerializableHeaderValue, {
756
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
757
757
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
758
758
  });
759
759
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
760
760
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
761
- const query = map({
761
+ const query = (0, smithy_client_1.map)({
762
762
  cors: [, ""],
763
763
  });
764
764
  let body;
@@ -776,12 +776,12 @@ const se_GetBucketCorsCommand = async (input, context) => {
776
776
  exports.se_GetBucketCorsCommand = se_GetBucketCorsCommand;
777
777
  const se_GetBucketEncryptionCommand = async (input, context) => {
778
778
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
779
- const headers = map({}, isSerializableHeaderValue, {
779
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
780
780
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
781
781
  });
782
782
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
783
783
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
784
- const query = map({
784
+ const query = (0, smithy_client_1.map)({
785
785
  encryption: [, ""],
786
786
  });
787
787
  let body;
@@ -802,7 +802,7 @@ const se_GetBucketIntelligentTieringConfigurationCommand = async (input, context
802
802
  const headers = {};
803
803
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
804
804
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
805
- const query = map({
805
+ const query = (0, smithy_client_1.map)({
806
806
  "intelligent-tiering": [, ""],
807
807
  "x-id": [, "GetBucketIntelligentTieringConfiguration"],
808
808
  id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)],
@@ -822,12 +822,12 @@ const se_GetBucketIntelligentTieringConfigurationCommand = async (input, context
822
822
  exports.se_GetBucketIntelligentTieringConfigurationCommand = se_GetBucketIntelligentTieringConfigurationCommand;
823
823
  const se_GetBucketInventoryConfigurationCommand = async (input, context) => {
824
824
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
825
- const headers = map({}, isSerializableHeaderValue, {
825
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
826
826
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
827
827
  });
828
828
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
829
829
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
830
- const query = map({
830
+ const query = (0, smithy_client_1.map)({
831
831
  inventory: [, ""],
832
832
  "x-id": [, "GetBucketInventoryConfiguration"],
833
833
  id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)],
@@ -847,12 +847,12 @@ const se_GetBucketInventoryConfigurationCommand = async (input, context) => {
847
847
  exports.se_GetBucketInventoryConfigurationCommand = se_GetBucketInventoryConfigurationCommand;
848
848
  const se_GetBucketLifecycleConfigurationCommand = async (input, context) => {
849
849
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
850
- const headers = map({}, isSerializableHeaderValue, {
850
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
851
851
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
852
852
  });
853
853
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
854
854
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
855
- const query = map({
855
+ const query = (0, smithy_client_1.map)({
856
856
  lifecycle: [, ""],
857
857
  });
858
858
  let body;
@@ -870,12 +870,12 @@ const se_GetBucketLifecycleConfigurationCommand = async (input, context) => {
870
870
  exports.se_GetBucketLifecycleConfigurationCommand = se_GetBucketLifecycleConfigurationCommand;
871
871
  const se_GetBucketLocationCommand = async (input, context) => {
872
872
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
873
- const headers = map({}, isSerializableHeaderValue, {
873
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
874
874
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
875
875
  });
876
876
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
877
877
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
878
- const query = map({
878
+ const query = (0, smithy_client_1.map)({
879
879
  location: [, ""],
880
880
  });
881
881
  let body;
@@ -893,12 +893,12 @@ const se_GetBucketLocationCommand = async (input, context) => {
893
893
  exports.se_GetBucketLocationCommand = se_GetBucketLocationCommand;
894
894
  const se_GetBucketLoggingCommand = async (input, context) => {
895
895
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
896
- const headers = map({}, isSerializableHeaderValue, {
896
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
897
897
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
898
898
  });
899
899
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
900
900
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
901
- const query = map({
901
+ const query = (0, smithy_client_1.map)({
902
902
  logging: [, ""],
903
903
  });
904
904
  let body;
@@ -916,12 +916,12 @@ const se_GetBucketLoggingCommand = async (input, context) => {
916
916
  exports.se_GetBucketLoggingCommand = se_GetBucketLoggingCommand;
917
917
  const se_GetBucketMetricsConfigurationCommand = async (input, context) => {
918
918
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
919
- const headers = map({}, isSerializableHeaderValue, {
919
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
920
920
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
921
921
  });
922
922
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
923
923
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
924
- const query = map({
924
+ const query = (0, smithy_client_1.map)({
925
925
  metrics: [, ""],
926
926
  "x-id": [, "GetBucketMetricsConfiguration"],
927
927
  id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)],
@@ -941,12 +941,12 @@ const se_GetBucketMetricsConfigurationCommand = async (input, context) => {
941
941
  exports.se_GetBucketMetricsConfigurationCommand = se_GetBucketMetricsConfigurationCommand;
942
942
  const se_GetBucketNotificationConfigurationCommand = async (input, context) => {
943
943
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
944
- const headers = map({}, isSerializableHeaderValue, {
944
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
945
945
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
946
946
  });
947
947
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
948
948
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
949
- const query = map({
949
+ const query = (0, smithy_client_1.map)({
950
950
  notification: [, ""],
951
951
  });
952
952
  let body;
@@ -964,12 +964,12 @@ const se_GetBucketNotificationConfigurationCommand = async (input, context) => {
964
964
  exports.se_GetBucketNotificationConfigurationCommand = se_GetBucketNotificationConfigurationCommand;
965
965
  const se_GetBucketOwnershipControlsCommand = async (input, context) => {
966
966
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
967
- const headers = map({}, isSerializableHeaderValue, {
967
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
968
968
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
969
969
  });
970
970
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
971
971
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
972
- const query = map({
972
+ const query = (0, smithy_client_1.map)({
973
973
  ownershipControls: [, ""],
974
974
  });
975
975
  let body;
@@ -987,12 +987,12 @@ const se_GetBucketOwnershipControlsCommand = async (input, context) => {
987
987
  exports.se_GetBucketOwnershipControlsCommand = se_GetBucketOwnershipControlsCommand;
988
988
  const se_GetBucketPolicyCommand = async (input, context) => {
989
989
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
990
- const headers = map({}, isSerializableHeaderValue, {
990
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
991
991
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
992
992
  });
993
993
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
994
994
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
995
- const query = map({
995
+ const query = (0, smithy_client_1.map)({
996
996
  policy: [, ""],
997
997
  });
998
998
  let body;
@@ -1010,12 +1010,12 @@ const se_GetBucketPolicyCommand = async (input, context) => {
1010
1010
  exports.se_GetBucketPolicyCommand = se_GetBucketPolicyCommand;
1011
1011
  const se_GetBucketPolicyStatusCommand = async (input, context) => {
1012
1012
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1013
- const headers = map({}, isSerializableHeaderValue, {
1013
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1014
1014
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1015
1015
  });
1016
1016
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1017
1017
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1018
- const query = map({
1018
+ const query = (0, smithy_client_1.map)({
1019
1019
  policyStatus: [, ""],
1020
1020
  });
1021
1021
  let body;
@@ -1033,12 +1033,12 @@ const se_GetBucketPolicyStatusCommand = async (input, context) => {
1033
1033
  exports.se_GetBucketPolicyStatusCommand = se_GetBucketPolicyStatusCommand;
1034
1034
  const se_GetBucketReplicationCommand = async (input, context) => {
1035
1035
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1036
- const headers = map({}, isSerializableHeaderValue, {
1036
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1037
1037
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1038
1038
  });
1039
1039
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1040
1040
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1041
- const query = map({
1041
+ const query = (0, smithy_client_1.map)({
1042
1042
  replication: [, ""],
1043
1043
  });
1044
1044
  let body;
@@ -1056,12 +1056,12 @@ const se_GetBucketReplicationCommand = async (input, context) => {
1056
1056
  exports.se_GetBucketReplicationCommand = se_GetBucketReplicationCommand;
1057
1057
  const se_GetBucketRequestPaymentCommand = async (input, context) => {
1058
1058
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1059
- const headers = map({}, isSerializableHeaderValue, {
1059
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1060
1060
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1061
1061
  });
1062
1062
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1063
1063
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1064
- const query = map({
1064
+ const query = (0, smithy_client_1.map)({
1065
1065
  requestPayment: [, ""],
1066
1066
  });
1067
1067
  let body;
@@ -1079,12 +1079,12 @@ const se_GetBucketRequestPaymentCommand = async (input, context) => {
1079
1079
  exports.se_GetBucketRequestPaymentCommand = se_GetBucketRequestPaymentCommand;
1080
1080
  const se_GetBucketTaggingCommand = async (input, context) => {
1081
1081
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1082
- const headers = map({}, isSerializableHeaderValue, {
1082
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1083
1083
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1084
1084
  });
1085
1085
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1086
1086
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1087
- const query = map({
1087
+ const query = (0, smithy_client_1.map)({
1088
1088
  tagging: [, ""],
1089
1089
  });
1090
1090
  let body;
@@ -1102,12 +1102,12 @@ const se_GetBucketTaggingCommand = async (input, context) => {
1102
1102
  exports.se_GetBucketTaggingCommand = se_GetBucketTaggingCommand;
1103
1103
  const se_GetBucketVersioningCommand = async (input, context) => {
1104
1104
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1105
- const headers = map({}, isSerializableHeaderValue, {
1105
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1106
1106
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1107
1107
  });
1108
1108
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1109
1109
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1110
- const query = map({
1110
+ const query = (0, smithy_client_1.map)({
1111
1111
  versioning: [, ""],
1112
1112
  });
1113
1113
  let body;
@@ -1125,12 +1125,12 @@ const se_GetBucketVersioningCommand = async (input, context) => {
1125
1125
  exports.se_GetBucketVersioningCommand = se_GetBucketVersioningCommand;
1126
1126
  const se_GetBucketWebsiteCommand = async (input, context) => {
1127
1127
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1128
- const headers = map({}, isSerializableHeaderValue, {
1128
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1129
1129
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1130
1130
  });
1131
1131
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1132
1132
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1133
- const query = map({
1133
+ const query = (0, smithy_client_1.map)({
1134
1134
  website: [, ""],
1135
1135
  });
1136
1136
  let body;
@@ -1148,7 +1148,7 @@ const se_GetBucketWebsiteCommand = async (input, context) => {
1148
1148
  exports.se_GetBucketWebsiteCommand = se_GetBucketWebsiteCommand;
1149
1149
  const se_GetObjectCommand = async (input, context) => {
1150
1150
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1151
- const headers = map({}, isSerializableHeaderValue, {
1151
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1152
1152
  "if-match": input.IfMatch,
1153
1153
  "if-modified-since": [
1154
1154
  () => isSerializableHeaderValue(input.IfModifiedSince),
@@ -1170,7 +1170,7 @@ const se_GetObjectCommand = async (input, context) => {
1170
1170
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
1171
1171
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1172
1172
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
1173
- const query = map({
1173
+ const query = (0, smithy_client_1.map)({
1174
1174
  "x-id": [, "GetObject"],
1175
1175
  "response-cache-control": [, input.ResponseCacheControl],
1176
1176
  "response-content-disposition": [, input.ResponseContentDisposition],
@@ -1199,14 +1199,14 @@ const se_GetObjectCommand = async (input, context) => {
1199
1199
  exports.se_GetObjectCommand = se_GetObjectCommand;
1200
1200
  const se_GetObjectAclCommand = async (input, context) => {
1201
1201
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1202
- const headers = map({}, isSerializableHeaderValue, {
1202
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1203
1203
  "x-amz-request-payer": input.RequestPayer,
1204
1204
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1205
1205
  });
1206
1206
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
1207
1207
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1208
1208
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
1209
- const query = map({
1209
+ const query = (0, smithy_client_1.map)({
1210
1210
  acl: [, ""],
1211
1211
  versionId: [, input.VersionId],
1212
1212
  });
@@ -1225,7 +1225,7 @@ const se_GetObjectAclCommand = async (input, context) => {
1225
1225
  exports.se_GetObjectAclCommand = se_GetObjectAclCommand;
1226
1226
  const se_GetObjectAttributesCommand = async (input, context) => {
1227
1227
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1228
- const headers = map({}, isSerializableHeaderValue, {
1228
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1229
1229
  "x-amz-max-parts": [() => isSerializableHeaderValue(input.MaxParts), () => input.MaxParts.toString()],
1230
1230
  "x-amz-part-number-marker": input.PartNumberMarker,
1231
1231
  "x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm,
@@ -1241,7 +1241,7 @@ const se_GetObjectAttributesCommand = async (input, context) => {
1241
1241
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
1242
1242
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1243
1243
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
1244
- const query = map({
1244
+ const query = (0, smithy_client_1.map)({
1245
1245
  attributes: [, ""],
1246
1246
  versionId: [, input.VersionId],
1247
1247
  });
@@ -1260,14 +1260,14 @@ const se_GetObjectAttributesCommand = async (input, context) => {
1260
1260
  exports.se_GetObjectAttributesCommand = se_GetObjectAttributesCommand;
1261
1261
  const se_GetObjectLegalHoldCommand = async (input, context) => {
1262
1262
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1263
- const headers = map({}, isSerializableHeaderValue, {
1263
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1264
1264
  "x-amz-request-payer": input.RequestPayer,
1265
1265
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1266
1266
  });
1267
1267
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
1268
1268
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1269
1269
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
1270
- const query = map({
1270
+ const query = (0, smithy_client_1.map)({
1271
1271
  "legal-hold": [, ""],
1272
1272
  versionId: [, input.VersionId],
1273
1273
  });
@@ -1286,12 +1286,12 @@ const se_GetObjectLegalHoldCommand = async (input, context) => {
1286
1286
  exports.se_GetObjectLegalHoldCommand = se_GetObjectLegalHoldCommand;
1287
1287
  const se_GetObjectLockConfigurationCommand = async (input, context) => {
1288
1288
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1289
- const headers = map({}, isSerializableHeaderValue, {
1289
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1290
1290
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1291
1291
  });
1292
1292
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1293
1293
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1294
- const query = map({
1294
+ const query = (0, smithy_client_1.map)({
1295
1295
  "object-lock": [, ""],
1296
1296
  });
1297
1297
  let body;
@@ -1309,14 +1309,14 @@ const se_GetObjectLockConfigurationCommand = async (input, context) => {
1309
1309
  exports.se_GetObjectLockConfigurationCommand = se_GetObjectLockConfigurationCommand;
1310
1310
  const se_GetObjectRetentionCommand = async (input, context) => {
1311
1311
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1312
- const headers = map({}, isSerializableHeaderValue, {
1312
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1313
1313
  "x-amz-request-payer": input.RequestPayer,
1314
1314
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1315
1315
  });
1316
1316
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
1317
1317
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1318
1318
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
1319
- const query = map({
1319
+ const query = (0, smithy_client_1.map)({
1320
1320
  retention: [, ""],
1321
1321
  versionId: [, input.VersionId],
1322
1322
  });
@@ -1335,14 +1335,14 @@ const se_GetObjectRetentionCommand = async (input, context) => {
1335
1335
  exports.se_GetObjectRetentionCommand = se_GetObjectRetentionCommand;
1336
1336
  const se_GetObjectTaggingCommand = async (input, context) => {
1337
1337
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1338
- const headers = map({}, isSerializableHeaderValue, {
1338
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1339
1339
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1340
1340
  "x-amz-request-payer": input.RequestPayer,
1341
1341
  });
1342
1342
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
1343
1343
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1344
1344
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
1345
- const query = map({
1345
+ const query = (0, smithy_client_1.map)({
1346
1346
  tagging: [, ""],
1347
1347
  versionId: [, input.VersionId],
1348
1348
  });
@@ -1361,14 +1361,14 @@ const se_GetObjectTaggingCommand = async (input, context) => {
1361
1361
  exports.se_GetObjectTaggingCommand = se_GetObjectTaggingCommand;
1362
1362
  const se_GetObjectTorrentCommand = async (input, context) => {
1363
1363
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1364
- const headers = map({}, isSerializableHeaderValue, {
1364
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1365
1365
  "x-amz-request-payer": input.RequestPayer,
1366
1366
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1367
1367
  });
1368
1368
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
1369
1369
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1370
1370
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
1371
- const query = map({
1371
+ const query = (0, smithy_client_1.map)({
1372
1372
  torrent: [, ""],
1373
1373
  });
1374
1374
  let body;
@@ -1386,12 +1386,12 @@ const se_GetObjectTorrentCommand = async (input, context) => {
1386
1386
  exports.se_GetObjectTorrentCommand = se_GetObjectTorrentCommand;
1387
1387
  const se_GetPublicAccessBlockCommand = async (input, context) => {
1388
1388
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1389
- const headers = map({}, isSerializableHeaderValue, {
1389
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1390
1390
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1391
1391
  });
1392
1392
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1393
1393
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1394
- const query = map({
1394
+ const query = (0, smithy_client_1.map)({
1395
1395
  publicAccessBlock: [, ""],
1396
1396
  });
1397
1397
  let body;
@@ -1409,7 +1409,7 @@ const se_GetPublicAccessBlockCommand = async (input, context) => {
1409
1409
  exports.se_GetPublicAccessBlockCommand = se_GetPublicAccessBlockCommand;
1410
1410
  const se_HeadBucketCommand = async (input, context) => {
1411
1411
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1412
- const headers = map({}, isSerializableHeaderValue, {
1412
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1413
1413
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1414
1414
  });
1415
1415
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
@@ -1428,7 +1428,7 @@ const se_HeadBucketCommand = async (input, context) => {
1428
1428
  exports.se_HeadBucketCommand = se_HeadBucketCommand;
1429
1429
  const se_HeadObjectCommand = async (input, context) => {
1430
1430
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1431
- const headers = map({}, isSerializableHeaderValue, {
1431
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1432
1432
  "if-match": input.IfMatch,
1433
1433
  "if-modified-since": [
1434
1434
  () => isSerializableHeaderValue(input.IfModifiedSince),
@@ -1450,7 +1450,7 @@ const se_HeadObjectCommand = async (input, context) => {
1450
1450
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
1451
1451
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1452
1452
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
1453
- const query = map({
1453
+ const query = (0, smithy_client_1.map)({
1454
1454
  versionId: [, input.VersionId],
1455
1455
  partNumber: [() => input.PartNumber !== void 0, () => input.PartNumber.toString()],
1456
1456
  });
@@ -1469,12 +1469,12 @@ const se_HeadObjectCommand = async (input, context) => {
1469
1469
  exports.se_HeadObjectCommand = se_HeadObjectCommand;
1470
1470
  const se_ListBucketAnalyticsConfigurationsCommand = async (input, context) => {
1471
1471
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1472
- const headers = map({}, isSerializableHeaderValue, {
1472
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1473
1473
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1474
1474
  });
1475
1475
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1476
1476
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1477
- const query = map({
1477
+ const query = (0, smithy_client_1.map)({
1478
1478
  analytics: [, ""],
1479
1479
  "x-id": [, "ListBucketAnalyticsConfigurations"],
1480
1480
  "continuation-token": [, input.ContinuationToken],
@@ -1497,7 +1497,7 @@ const se_ListBucketIntelligentTieringConfigurationsCommand = async (input, conte
1497
1497
  const headers = {};
1498
1498
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1499
1499
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1500
- const query = map({
1500
+ const query = (0, smithy_client_1.map)({
1501
1501
  "intelligent-tiering": [, ""],
1502
1502
  "x-id": [, "ListBucketIntelligentTieringConfigurations"],
1503
1503
  "continuation-token": [, input.ContinuationToken],
@@ -1517,12 +1517,12 @@ const se_ListBucketIntelligentTieringConfigurationsCommand = async (input, conte
1517
1517
  exports.se_ListBucketIntelligentTieringConfigurationsCommand = se_ListBucketIntelligentTieringConfigurationsCommand;
1518
1518
  const se_ListBucketInventoryConfigurationsCommand = async (input, context) => {
1519
1519
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1520
- const headers = map({}, isSerializableHeaderValue, {
1520
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1521
1521
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1522
1522
  });
1523
1523
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1524
1524
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1525
- const query = map({
1525
+ const query = (0, smithy_client_1.map)({
1526
1526
  inventory: [, ""],
1527
1527
  "x-id": [, "ListBucketInventoryConfigurations"],
1528
1528
  "continuation-token": [, input.ContinuationToken],
@@ -1542,12 +1542,12 @@ const se_ListBucketInventoryConfigurationsCommand = async (input, context) => {
1542
1542
  exports.se_ListBucketInventoryConfigurationsCommand = se_ListBucketInventoryConfigurationsCommand;
1543
1543
  const se_ListBucketMetricsConfigurationsCommand = async (input, context) => {
1544
1544
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1545
- const headers = map({}, isSerializableHeaderValue, {
1545
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1546
1546
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1547
1547
  });
1548
1548
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1549
1549
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1550
- const query = map({
1550
+ const query = (0, smithy_client_1.map)({
1551
1551
  metrics: [, ""],
1552
1552
  "x-id": [, "ListBucketMetricsConfigurations"],
1553
1553
  "continuation-token": [, input.ContinuationToken],
@@ -1586,12 +1586,12 @@ const se_ListBucketsCommand = async (input, context) => {
1586
1586
  exports.se_ListBucketsCommand = se_ListBucketsCommand;
1587
1587
  const se_ListMultipartUploadsCommand = async (input, context) => {
1588
1588
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1589
- const headers = map({}, isSerializableHeaderValue, {
1589
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1590
1590
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1591
1591
  });
1592
1592
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1593
1593
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1594
- const query = map({
1594
+ const query = (0, smithy_client_1.map)({
1595
1595
  uploads: [, ""],
1596
1596
  delimiter: [, input.Delimiter],
1597
1597
  "encoding-type": [, input.EncodingType],
@@ -1615,13 +1615,13 @@ const se_ListMultipartUploadsCommand = async (input, context) => {
1615
1615
  exports.se_ListMultipartUploadsCommand = se_ListMultipartUploadsCommand;
1616
1616
  const se_ListObjectsCommand = async (input, context) => {
1617
1617
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1618
- const headers = map({}, isSerializableHeaderValue, {
1618
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1619
1619
  "x-amz-request-payer": input.RequestPayer,
1620
1620
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1621
1621
  });
1622
1622
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1623
1623
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1624
- const query = map({
1624
+ const query = (0, smithy_client_1.map)({
1625
1625
  delimiter: [, input.Delimiter],
1626
1626
  "encoding-type": [, input.EncodingType],
1627
1627
  marker: [, input.Marker],
@@ -1643,13 +1643,13 @@ const se_ListObjectsCommand = async (input, context) => {
1643
1643
  exports.se_ListObjectsCommand = se_ListObjectsCommand;
1644
1644
  const se_ListObjectsV2Command = async (input, context) => {
1645
1645
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1646
- const headers = map({}, isSerializableHeaderValue, {
1646
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1647
1647
  "x-amz-request-payer": input.RequestPayer,
1648
1648
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1649
1649
  });
1650
1650
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1651
1651
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1652
- const query = map({
1652
+ const query = (0, smithy_client_1.map)({
1653
1653
  "list-type": [, "2"],
1654
1654
  delimiter: [, input.Delimiter],
1655
1655
  "encoding-type": [, input.EncodingType],
@@ -1674,12 +1674,12 @@ const se_ListObjectsV2Command = async (input, context) => {
1674
1674
  exports.se_ListObjectsV2Command = se_ListObjectsV2Command;
1675
1675
  const se_ListObjectVersionsCommand = async (input, context) => {
1676
1676
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1677
- const headers = map({}, isSerializableHeaderValue, {
1677
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1678
1678
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1679
1679
  });
1680
1680
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1681
1681
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1682
- const query = map({
1682
+ const query = (0, smithy_client_1.map)({
1683
1683
  versions: [, ""],
1684
1684
  delimiter: [, input.Delimiter],
1685
1685
  "encoding-type": [, input.EncodingType],
@@ -1703,7 +1703,7 @@ const se_ListObjectVersionsCommand = async (input, context) => {
1703
1703
  exports.se_ListObjectVersionsCommand = se_ListObjectVersionsCommand;
1704
1704
  const se_ListPartsCommand = async (input, context) => {
1705
1705
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1706
- const headers = map({}, isSerializableHeaderValue, {
1706
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1707
1707
  "x-amz-request-payer": input.RequestPayer,
1708
1708
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1709
1709
  "x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm,
@@ -1713,7 +1713,7 @@ const se_ListPartsCommand = async (input, context) => {
1713
1713
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
1714
1714
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1715
1715
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
1716
- const query = map({
1716
+ const query = (0, smithy_client_1.map)({
1717
1717
  "x-id": [, "ListParts"],
1718
1718
  "max-parts": [() => input.MaxParts !== void 0, () => input.MaxParts.toString()],
1719
1719
  "part-number-marker": [, input.PartNumberMarker],
@@ -1734,14 +1734,14 @@ const se_ListPartsCommand = async (input, context) => {
1734
1734
  exports.se_ListPartsCommand = se_ListPartsCommand;
1735
1735
  const se_PutBucketAccelerateConfigurationCommand = async (input, context) => {
1736
1736
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1737
- const headers = map({}, isSerializableHeaderValue, {
1737
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1738
1738
  "content-type": "application/xml",
1739
1739
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1740
1740
  "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
1741
1741
  });
1742
1742
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1743
1743
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1744
- const query = map({
1744
+ const query = (0, smithy_client_1.map)({
1745
1745
  accelerate: [, ""],
1746
1746
  });
1747
1747
  let body;
@@ -1769,7 +1769,7 @@ const se_PutBucketAccelerateConfigurationCommand = async (input, context) => {
1769
1769
  exports.se_PutBucketAccelerateConfigurationCommand = se_PutBucketAccelerateConfigurationCommand;
1770
1770
  const se_PutBucketAclCommand = async (input, context) => {
1771
1771
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1772
- const headers = map({}, isSerializableHeaderValue, {
1772
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1773
1773
  "content-type": "application/xml",
1774
1774
  "x-amz-acl": input.ACL,
1775
1775
  "content-md5": input.ContentMD5,
@@ -1783,7 +1783,7 @@ const se_PutBucketAclCommand = async (input, context) => {
1783
1783
  });
1784
1784
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1785
1785
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1786
- const query = map({
1786
+ const query = (0, smithy_client_1.map)({
1787
1787
  acl: [, ""],
1788
1788
  });
1789
1789
  let body;
@@ -1811,13 +1811,13 @@ const se_PutBucketAclCommand = async (input, context) => {
1811
1811
  exports.se_PutBucketAclCommand = se_PutBucketAclCommand;
1812
1812
  const se_PutBucketAnalyticsConfigurationCommand = async (input, context) => {
1813
1813
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1814
- const headers = map({}, isSerializableHeaderValue, {
1814
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1815
1815
  "content-type": "application/xml",
1816
1816
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1817
1817
  });
1818
1818
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1819
1819
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1820
- const query = map({
1820
+ const query = (0, smithy_client_1.map)({
1821
1821
  analytics: [, ""],
1822
1822
  id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)],
1823
1823
  });
@@ -1846,7 +1846,7 @@ const se_PutBucketAnalyticsConfigurationCommand = async (input, context) => {
1846
1846
  exports.se_PutBucketAnalyticsConfigurationCommand = se_PutBucketAnalyticsConfigurationCommand;
1847
1847
  const se_PutBucketCorsCommand = async (input, context) => {
1848
1848
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1849
- const headers = map({}, isSerializableHeaderValue, {
1849
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1850
1850
  "content-type": "application/xml",
1851
1851
  "content-md5": input.ContentMD5,
1852
1852
  "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
@@ -1854,7 +1854,7 @@ const se_PutBucketCorsCommand = async (input, context) => {
1854
1854
  });
1855
1855
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1856
1856
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1857
- const query = map({
1857
+ const query = (0, smithy_client_1.map)({
1858
1858
  cors: [, ""],
1859
1859
  });
1860
1860
  let body;
@@ -1882,7 +1882,7 @@ const se_PutBucketCorsCommand = async (input, context) => {
1882
1882
  exports.se_PutBucketCorsCommand = se_PutBucketCorsCommand;
1883
1883
  const se_PutBucketEncryptionCommand = async (input, context) => {
1884
1884
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1885
- const headers = map({}, isSerializableHeaderValue, {
1885
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1886
1886
  "content-type": "application/xml",
1887
1887
  "content-md5": input.ContentMD5,
1888
1888
  "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
@@ -1890,7 +1890,7 @@ const se_PutBucketEncryptionCommand = async (input, context) => {
1890
1890
  });
1891
1891
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1892
1892
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1893
- const query = map({
1893
+ const query = (0, smithy_client_1.map)({
1894
1894
  encryption: [, ""],
1895
1895
  });
1896
1896
  let body;
@@ -1923,7 +1923,7 @@ const se_PutBucketIntelligentTieringConfigurationCommand = async (input, context
1923
1923
  };
1924
1924
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1925
1925
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1926
- const query = map({
1926
+ const query = (0, smithy_client_1.map)({
1927
1927
  "intelligent-tiering": [, ""],
1928
1928
  id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)],
1929
1929
  });
@@ -1952,13 +1952,13 @@ const se_PutBucketIntelligentTieringConfigurationCommand = async (input, context
1952
1952
  exports.se_PutBucketIntelligentTieringConfigurationCommand = se_PutBucketIntelligentTieringConfigurationCommand;
1953
1953
  const se_PutBucketInventoryConfigurationCommand = async (input, context) => {
1954
1954
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1955
- const headers = map({}, isSerializableHeaderValue, {
1955
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1956
1956
  "content-type": "application/xml",
1957
1957
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1958
1958
  });
1959
1959
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1960
1960
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1961
- const query = map({
1961
+ const query = (0, smithy_client_1.map)({
1962
1962
  inventory: [, ""],
1963
1963
  id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)],
1964
1964
  });
@@ -1987,14 +1987,14 @@ const se_PutBucketInventoryConfigurationCommand = async (input, context) => {
1987
1987
  exports.se_PutBucketInventoryConfigurationCommand = se_PutBucketInventoryConfigurationCommand;
1988
1988
  const se_PutBucketLifecycleConfigurationCommand = async (input, context) => {
1989
1989
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
1990
- const headers = map({}, isSerializableHeaderValue, {
1990
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
1991
1991
  "content-type": "application/xml",
1992
1992
  "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
1993
1993
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
1994
1994
  });
1995
1995
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
1996
1996
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
1997
- const query = map({
1997
+ const query = (0, smithy_client_1.map)({
1998
1998
  lifecycle: [, ""],
1999
1999
  });
2000
2000
  let body;
@@ -2023,7 +2023,7 @@ const se_PutBucketLifecycleConfigurationCommand = async (input, context) => {
2023
2023
  exports.se_PutBucketLifecycleConfigurationCommand = se_PutBucketLifecycleConfigurationCommand;
2024
2024
  const se_PutBucketLoggingCommand = async (input, context) => {
2025
2025
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2026
- const headers = map({}, isSerializableHeaderValue, {
2026
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2027
2027
  "content-type": "application/xml",
2028
2028
  "content-md5": input.ContentMD5,
2029
2029
  "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
@@ -2031,7 +2031,7 @@ const se_PutBucketLoggingCommand = async (input, context) => {
2031
2031
  });
2032
2032
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
2033
2033
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2034
- const query = map({
2034
+ const query = (0, smithy_client_1.map)({
2035
2035
  logging: [, ""],
2036
2036
  });
2037
2037
  let body;
@@ -2059,13 +2059,13 @@ const se_PutBucketLoggingCommand = async (input, context) => {
2059
2059
  exports.se_PutBucketLoggingCommand = se_PutBucketLoggingCommand;
2060
2060
  const se_PutBucketMetricsConfigurationCommand = async (input, context) => {
2061
2061
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2062
- const headers = map({}, isSerializableHeaderValue, {
2062
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2063
2063
  "content-type": "application/xml",
2064
2064
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
2065
2065
  });
2066
2066
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
2067
2067
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2068
- const query = map({
2068
+ const query = (0, smithy_client_1.map)({
2069
2069
  metrics: [, ""],
2070
2070
  id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)],
2071
2071
  });
@@ -2094,7 +2094,7 @@ const se_PutBucketMetricsConfigurationCommand = async (input, context) => {
2094
2094
  exports.se_PutBucketMetricsConfigurationCommand = se_PutBucketMetricsConfigurationCommand;
2095
2095
  const se_PutBucketNotificationConfigurationCommand = async (input, context) => {
2096
2096
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2097
- const headers = map({}, isSerializableHeaderValue, {
2097
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2098
2098
  "content-type": "application/xml",
2099
2099
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
2100
2100
  "x-amz-skip-destination-validation": [
@@ -2104,7 +2104,7 @@ const se_PutBucketNotificationConfigurationCommand = async (input, context) => {
2104
2104
  });
2105
2105
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
2106
2106
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2107
- const query = map({
2107
+ const query = (0, smithy_client_1.map)({
2108
2108
  notification: [, ""],
2109
2109
  });
2110
2110
  let body;
@@ -2132,14 +2132,14 @@ const se_PutBucketNotificationConfigurationCommand = async (input, context) => {
2132
2132
  exports.se_PutBucketNotificationConfigurationCommand = se_PutBucketNotificationConfigurationCommand;
2133
2133
  const se_PutBucketOwnershipControlsCommand = async (input, context) => {
2134
2134
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2135
- const headers = map({}, isSerializableHeaderValue, {
2135
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2136
2136
  "content-type": "application/xml",
2137
2137
  "content-md5": input.ContentMD5,
2138
2138
  "x-amz-expected-bucket-owner": input.ExpectedBucketOwner,
2139
2139
  });
2140
2140
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
2141
2141
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2142
- const query = map({
2142
+ const query = (0, smithy_client_1.map)({
2143
2143
  ownershipControls: [, ""],
2144
2144
  });
2145
2145
  let body;
@@ -2167,7 +2167,7 @@ const se_PutBucketOwnershipControlsCommand = async (input, context) => {
2167
2167
  exports.se_PutBucketOwnershipControlsCommand = se_PutBucketOwnershipControlsCommand;
2168
2168
  const se_PutBucketPolicyCommand = async (input, context) => {
2169
2169
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2170
- const headers = map({}, isSerializableHeaderValue, {
2170
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2171
2171
  "content-type": "text/plain",
2172
2172
  "content-md5": input.ContentMD5,
2173
2173
  "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
@@ -2179,7 +2179,7 @@ const se_PutBucketPolicyCommand = async (input, context) => {
2179
2179
  });
2180
2180
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
2181
2181
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2182
- const query = map({
2182
+ const query = (0, smithy_client_1.map)({
2183
2183
  policy: [, ""],
2184
2184
  });
2185
2185
  let body;
@@ -2205,7 +2205,7 @@ const se_PutBucketPolicyCommand = async (input, context) => {
2205
2205
  exports.se_PutBucketPolicyCommand = se_PutBucketPolicyCommand;
2206
2206
  const se_PutBucketReplicationCommand = async (input, context) => {
2207
2207
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2208
- const headers = map({}, isSerializableHeaderValue, {
2208
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2209
2209
  "content-type": "application/xml",
2210
2210
  "content-md5": input.ContentMD5,
2211
2211
  "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
@@ -2214,7 +2214,7 @@ const se_PutBucketReplicationCommand = async (input, context) => {
2214
2214
  });
2215
2215
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
2216
2216
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2217
- const query = map({
2217
+ const query = (0, smithy_client_1.map)({
2218
2218
  replication: [, ""],
2219
2219
  });
2220
2220
  let body;
@@ -2242,7 +2242,7 @@ const se_PutBucketReplicationCommand = async (input, context) => {
2242
2242
  exports.se_PutBucketReplicationCommand = se_PutBucketReplicationCommand;
2243
2243
  const se_PutBucketRequestPaymentCommand = async (input, context) => {
2244
2244
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2245
- const headers = map({}, isSerializableHeaderValue, {
2245
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2246
2246
  "content-type": "application/xml",
2247
2247
  "content-md5": input.ContentMD5,
2248
2248
  "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
@@ -2250,7 +2250,7 @@ const se_PutBucketRequestPaymentCommand = async (input, context) => {
2250
2250
  });
2251
2251
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
2252
2252
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2253
- const query = map({
2253
+ const query = (0, smithy_client_1.map)({
2254
2254
  requestPayment: [, ""],
2255
2255
  });
2256
2256
  let body;
@@ -2278,7 +2278,7 @@ const se_PutBucketRequestPaymentCommand = async (input, context) => {
2278
2278
  exports.se_PutBucketRequestPaymentCommand = se_PutBucketRequestPaymentCommand;
2279
2279
  const se_PutBucketTaggingCommand = async (input, context) => {
2280
2280
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2281
- const headers = map({}, isSerializableHeaderValue, {
2281
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2282
2282
  "content-type": "application/xml",
2283
2283
  "content-md5": input.ContentMD5,
2284
2284
  "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
@@ -2286,7 +2286,7 @@ const se_PutBucketTaggingCommand = async (input, context) => {
2286
2286
  });
2287
2287
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
2288
2288
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2289
- const query = map({
2289
+ const query = (0, smithy_client_1.map)({
2290
2290
  tagging: [, ""],
2291
2291
  });
2292
2292
  let body;
@@ -2314,7 +2314,7 @@ const se_PutBucketTaggingCommand = async (input, context) => {
2314
2314
  exports.se_PutBucketTaggingCommand = se_PutBucketTaggingCommand;
2315
2315
  const se_PutBucketVersioningCommand = async (input, context) => {
2316
2316
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2317
- const headers = map({}, isSerializableHeaderValue, {
2317
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2318
2318
  "content-type": "application/xml",
2319
2319
  "content-md5": input.ContentMD5,
2320
2320
  "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
@@ -2323,7 +2323,7 @@ const se_PutBucketVersioningCommand = async (input, context) => {
2323
2323
  });
2324
2324
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
2325
2325
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2326
- const query = map({
2326
+ const query = (0, smithy_client_1.map)({
2327
2327
  versioning: [, ""],
2328
2328
  });
2329
2329
  let body;
@@ -2351,7 +2351,7 @@ const se_PutBucketVersioningCommand = async (input, context) => {
2351
2351
  exports.se_PutBucketVersioningCommand = se_PutBucketVersioningCommand;
2352
2352
  const se_PutBucketWebsiteCommand = async (input, context) => {
2353
2353
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2354
- const headers = map({}, isSerializableHeaderValue, {
2354
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2355
2355
  "content-type": "application/xml",
2356
2356
  "content-md5": input.ContentMD5,
2357
2357
  "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
@@ -2359,7 +2359,7 @@ const se_PutBucketWebsiteCommand = async (input, context) => {
2359
2359
  });
2360
2360
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
2361
2361
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2362
- const query = map({
2362
+ const query = (0, smithy_client_1.map)({
2363
2363
  website: [, ""],
2364
2364
  });
2365
2365
  let body;
@@ -2387,7 +2387,7 @@ const se_PutBucketWebsiteCommand = async (input, context) => {
2387
2387
  exports.se_PutBucketWebsiteCommand = se_PutBucketWebsiteCommand;
2388
2388
  const se_PutObjectCommand = async (input, context) => {
2389
2389
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2390
- const headers = map({}, isSerializableHeaderValue, {
2390
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2391
2391
  "content-type": input.ContentType || "application/octet-stream",
2392
2392
  "x-amz-acl": input.ACL,
2393
2393
  "cache-control": input.CacheControl,
@@ -2436,7 +2436,7 @@ const se_PutObjectCommand = async (input, context) => {
2436
2436
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
2437
2437
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2438
2438
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
2439
- const query = map({
2439
+ const query = (0, smithy_client_1.map)({
2440
2440
  "x-id": [, "PutObject"],
2441
2441
  });
2442
2442
  let body;
@@ -2462,7 +2462,7 @@ const se_PutObjectCommand = async (input, context) => {
2462
2462
  exports.se_PutObjectCommand = se_PutObjectCommand;
2463
2463
  const se_PutObjectAclCommand = async (input, context) => {
2464
2464
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2465
- const headers = map({}, isSerializableHeaderValue, {
2465
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2466
2466
  "content-type": "application/xml",
2467
2467
  "x-amz-acl": input.ACL,
2468
2468
  "content-md5": input.ContentMD5,
@@ -2478,7 +2478,7 @@ const se_PutObjectAclCommand = async (input, context) => {
2478
2478
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
2479
2479
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2480
2480
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
2481
- const query = map({
2481
+ const query = (0, smithy_client_1.map)({
2482
2482
  acl: [, ""],
2483
2483
  versionId: [, input.VersionId],
2484
2484
  });
@@ -2507,7 +2507,7 @@ const se_PutObjectAclCommand = async (input, context) => {
2507
2507
  exports.se_PutObjectAclCommand = se_PutObjectAclCommand;
2508
2508
  const se_PutObjectLegalHoldCommand = async (input, context) => {
2509
2509
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2510
- const headers = map({}, isSerializableHeaderValue, {
2510
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2511
2511
  "content-type": "application/xml",
2512
2512
  "x-amz-request-payer": input.RequestPayer,
2513
2513
  "content-md5": input.ContentMD5,
@@ -2517,7 +2517,7 @@ const se_PutObjectLegalHoldCommand = async (input, context) => {
2517
2517
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
2518
2518
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2519
2519
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
2520
- const query = map({
2520
+ const query = (0, smithy_client_1.map)({
2521
2521
  "legal-hold": [, ""],
2522
2522
  versionId: [, input.VersionId],
2523
2523
  });
@@ -2547,7 +2547,7 @@ const se_PutObjectLegalHoldCommand = async (input, context) => {
2547
2547
  exports.se_PutObjectLegalHoldCommand = se_PutObjectLegalHoldCommand;
2548
2548
  const se_PutObjectLockConfigurationCommand = async (input, context) => {
2549
2549
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2550
- const headers = map({}, isSerializableHeaderValue, {
2550
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2551
2551
  "content-type": "application/xml",
2552
2552
  "x-amz-request-payer": input.RequestPayer,
2553
2553
  "x-amz-bucket-object-lock-token": input.Token,
@@ -2557,7 +2557,7 @@ const se_PutObjectLockConfigurationCommand = async (input, context) => {
2557
2557
  });
2558
2558
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
2559
2559
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2560
- const query = map({
2560
+ const query = (0, smithy_client_1.map)({
2561
2561
  "object-lock": [, ""],
2562
2562
  });
2563
2563
  let body;
@@ -2585,7 +2585,7 @@ const se_PutObjectLockConfigurationCommand = async (input, context) => {
2585
2585
  exports.se_PutObjectLockConfigurationCommand = se_PutObjectLockConfigurationCommand;
2586
2586
  const se_PutObjectRetentionCommand = async (input, context) => {
2587
2587
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2588
- const headers = map({}, isSerializableHeaderValue, {
2588
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2589
2589
  "content-type": "application/xml",
2590
2590
  "x-amz-request-payer": input.RequestPayer,
2591
2591
  "x-amz-bypass-governance-retention": [
@@ -2599,7 +2599,7 @@ const se_PutObjectRetentionCommand = async (input, context) => {
2599
2599
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
2600
2600
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2601
2601
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
2602
- const query = map({
2602
+ const query = (0, smithy_client_1.map)({
2603
2603
  retention: [, ""],
2604
2604
  versionId: [, input.VersionId],
2605
2605
  });
@@ -2629,7 +2629,7 @@ const se_PutObjectRetentionCommand = async (input, context) => {
2629
2629
  exports.se_PutObjectRetentionCommand = se_PutObjectRetentionCommand;
2630
2630
  const se_PutObjectTaggingCommand = async (input, context) => {
2631
2631
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2632
- const headers = map({}, isSerializableHeaderValue, {
2632
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2633
2633
  "content-type": "application/xml",
2634
2634
  "content-md5": input.ContentMD5,
2635
2635
  "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
@@ -2639,7 +2639,7 @@ const se_PutObjectTaggingCommand = async (input, context) => {
2639
2639
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
2640
2640
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2641
2641
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
2642
- const query = map({
2642
+ const query = (0, smithy_client_1.map)({
2643
2643
  tagging: [, ""],
2644
2644
  versionId: [, input.VersionId],
2645
2645
  });
@@ -2668,7 +2668,7 @@ const se_PutObjectTaggingCommand = async (input, context) => {
2668
2668
  exports.se_PutObjectTaggingCommand = se_PutObjectTaggingCommand;
2669
2669
  const se_PutPublicAccessBlockCommand = async (input, context) => {
2670
2670
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2671
- const headers = map({}, isSerializableHeaderValue, {
2671
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2672
2672
  "content-type": "application/xml",
2673
2673
  "content-md5": input.ContentMD5,
2674
2674
  "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
@@ -2676,7 +2676,7 @@ const se_PutPublicAccessBlockCommand = async (input, context) => {
2676
2676
  });
2677
2677
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/";
2678
2678
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2679
- const query = map({
2679
+ const query = (0, smithy_client_1.map)({
2680
2680
  publicAccessBlock: [, ""],
2681
2681
  });
2682
2682
  let body;
@@ -2704,7 +2704,7 @@ const se_PutPublicAccessBlockCommand = async (input, context) => {
2704
2704
  exports.se_PutPublicAccessBlockCommand = se_PutPublicAccessBlockCommand;
2705
2705
  const se_RestoreObjectCommand = async (input, context) => {
2706
2706
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2707
- const headers = map({}, isSerializableHeaderValue, {
2707
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2708
2708
  "content-type": "application/xml",
2709
2709
  "x-amz-request-payer": input.RequestPayer,
2710
2710
  "x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm,
@@ -2713,7 +2713,7 @@ const se_RestoreObjectCommand = async (input, context) => {
2713
2713
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
2714
2714
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2715
2715
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
2716
- const query = map({
2716
+ const query = (0, smithy_client_1.map)({
2717
2717
  restore: [, ""],
2718
2718
  "x-id": [, "RestoreObject"],
2719
2719
  versionId: [, input.VersionId],
@@ -2743,7 +2743,7 @@ const se_RestoreObjectCommand = async (input, context) => {
2743
2743
  exports.se_RestoreObjectCommand = se_RestoreObjectCommand;
2744
2744
  const se_SelectObjectContentCommand = async (input, context) => {
2745
2745
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2746
- const headers = map({}, isSerializableHeaderValue, {
2746
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2747
2747
  "content-type": "application/xml",
2748
2748
  "x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm,
2749
2749
  "x-amz-server-side-encryption-customer-key": input.SSECustomerKey,
@@ -2753,7 +2753,7 @@ const se_SelectObjectContentCommand = async (input, context) => {
2753
2753
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
2754
2754
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2755
2755
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
2756
- const query = map({
2756
+ const query = (0, smithy_client_1.map)({
2757
2757
  select: [, ""],
2758
2758
  "select-type": [, "2"],
2759
2759
  "x-id": [, "SelectObjectContent"],
@@ -2801,7 +2801,7 @@ const se_SelectObjectContentCommand = async (input, context) => {
2801
2801
  exports.se_SelectObjectContentCommand = se_SelectObjectContentCommand;
2802
2802
  const se_UploadPartCommand = async (input, context) => {
2803
2803
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2804
- const headers = map({}, isSerializableHeaderValue, {
2804
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2805
2805
  "content-type": "application/octet-stream",
2806
2806
  "content-length": [() => isSerializableHeaderValue(input.ContentLength), () => input.ContentLength.toString()],
2807
2807
  "content-md5": input.ContentMD5,
@@ -2819,7 +2819,7 @@ const se_UploadPartCommand = async (input, context) => {
2819
2819
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
2820
2820
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2821
2821
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
2822
- const query = map({
2822
+ const query = (0, smithy_client_1.map)({
2823
2823
  "x-id": [, "UploadPart"],
2824
2824
  partNumber: [(0, smithy_client_1.expectNonNull)(input.PartNumber, `PartNumber`) != null, () => input.PartNumber.toString()],
2825
2825
  uploadId: [, (0, smithy_client_1.expectNonNull)(input.UploadId, `UploadId`)],
@@ -2847,7 +2847,7 @@ const se_UploadPartCommand = async (input, context) => {
2847
2847
  exports.se_UploadPartCommand = se_UploadPartCommand;
2848
2848
  const se_UploadPartCopyCommand = async (input, context) => {
2849
2849
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2850
- const headers = map({}, isSerializableHeaderValue, {
2850
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2851
2851
  "x-amz-copy-source": input.CopySource,
2852
2852
  "x-amz-copy-source-if-match": input.CopySourceIfMatch,
2853
2853
  "x-amz-copy-source-if-modified-since": [
@@ -2873,7 +2873,7 @@ const se_UploadPartCopyCommand = async (input, context) => {
2873
2873
  let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/{Key+}";
2874
2874
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
2875
2875
  resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true);
2876
- const query = map({
2876
+ const query = (0, smithy_client_1.map)({
2877
2877
  "x-id": [, "UploadPartCopy"],
2878
2878
  partNumber: [(0, smithy_client_1.expectNonNull)(input.PartNumber, `PartNumber`) != null, () => input.PartNumber.toString()],
2879
2879
  uploadId: [, (0, smithy_client_1.expectNonNull)(input.UploadId, `UploadId`)],
@@ -2893,7 +2893,7 @@ const se_UploadPartCopyCommand = async (input, context) => {
2893
2893
  exports.se_UploadPartCopyCommand = se_UploadPartCopyCommand;
2894
2894
  const se_WriteGetObjectResponseCommand = async (input, context) => {
2895
2895
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
2896
- const headers = map({}, isSerializableHeaderValue, {
2896
+ const headers = (0, smithy_client_1.map)({}, isSerializableHeaderValue, {
2897
2897
  "x-amz-content-sha256": "UNSIGNED-PAYLOAD",
2898
2898
  "content-type": "application/octet-stream",
2899
2899
  "x-amz-request-route": input.RequestRoute,
@@ -2965,7 +2965,7 @@ const se_WriteGetObjectResponseCommand = async (input, context) => {
2965
2965
  }, {})),
2966
2966
  });
2967
2967
  const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/WriteGetObjectResponse";
2968
- const query = map({
2968
+ const query = (0, smithy_client_1.map)({
2969
2969
  "x-id": [, "WriteGetObjectResponse"],
2970
2970
  });
2971
2971
  let body;
@@ -3004,7 +3004,7 @@ const de_AbortMultipartUploadCommand = async (output, context) => {
3004
3004
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3005
3005
  return de_AbortMultipartUploadCommandError(output, context);
3006
3006
  }
3007
- const contents = map({
3007
+ const contents = (0, smithy_client_1.map)({
3008
3008
  $metadata: deserializeMetadata(output),
3009
3009
  RequestCharged: [, output.headers["x-amz-request-charged"]],
3010
3010
  });
@@ -3024,10 +3024,9 @@ const de_AbortMultipartUploadCommandError = async (output, context) => {
3024
3024
  throw await de_NoSuchUploadRes(parsedOutput, context);
3025
3025
  default:
3026
3026
  const parsedBody = parsedOutput.body;
3027
- (0, smithy_client_1.throwDefaultError)({
3027
+ return throwDefaultError({
3028
3028
  output,
3029
3029
  parsedBody,
3030
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3031
3030
  errorCode,
3032
3031
  });
3033
3032
  }
@@ -3036,7 +3035,7 @@ const de_CompleteMultipartUploadCommand = async (output, context) => {
3036
3035
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3037
3036
  return de_CompleteMultipartUploadCommandError(output, context);
3038
3037
  }
3039
- const contents = map({
3038
+ const contents = (0, smithy_client_1.map)({
3040
3039
  $metadata: deserializeMetadata(output),
3041
3040
  Expiration: [, output.headers["x-amz-expiration"]],
3042
3041
  ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]],
@@ -3083,10 +3082,9 @@ const de_CompleteMultipartUploadCommandError = async (output, context) => {
3083
3082
  };
3084
3083
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3085
3084
  const parsedBody = parsedOutput.body;
3086
- (0, smithy_client_1.throwDefaultError)({
3085
+ return throwDefaultError({
3087
3086
  output,
3088
3087
  parsedBody,
3089
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3090
3088
  errorCode,
3091
3089
  });
3092
3090
  };
@@ -3094,7 +3092,7 @@ const de_CopyObjectCommand = async (output, context) => {
3094
3092
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3095
3093
  return de_CopyObjectCommandError(output, context);
3096
3094
  }
3097
- const contents = map({
3095
+ const contents = (0, smithy_client_1.map)({
3098
3096
  $metadata: deserializeMetadata(output),
3099
3097
  Expiration: [, output.headers["x-amz-expiration"]],
3100
3098
  CopySourceVersionId: [, output.headers["x-amz-copy-source-version-id"]],
@@ -3127,10 +3125,9 @@ const de_CopyObjectCommandError = async (output, context) => {
3127
3125
  throw await de_ObjectNotInActiveTierErrorRes(parsedOutput, context);
3128
3126
  default:
3129
3127
  const parsedBody = parsedOutput.body;
3130
- (0, smithy_client_1.throwDefaultError)({
3128
+ return throwDefaultError({
3131
3129
  output,
3132
3130
  parsedBody,
3133
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3134
3131
  errorCode,
3135
3132
  });
3136
3133
  }
@@ -3139,7 +3136,7 @@ const de_CreateBucketCommand = async (output, context) => {
3139
3136
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3140
3137
  return de_CreateBucketCommandError(output, context);
3141
3138
  }
3142
- const contents = map({
3139
+ const contents = (0, smithy_client_1.map)({
3143
3140
  $metadata: deserializeMetadata(output),
3144
3141
  Location: [, output.headers["location"]],
3145
3142
  });
@@ -3162,10 +3159,9 @@ const de_CreateBucketCommandError = async (output, context) => {
3162
3159
  throw await de_BucketAlreadyOwnedByYouRes(parsedOutput, context);
3163
3160
  default:
3164
3161
  const parsedBody = parsedOutput.body;
3165
- (0, smithy_client_1.throwDefaultError)({
3162
+ return throwDefaultError({
3166
3163
  output,
3167
3164
  parsedBody,
3168
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3169
3165
  errorCode,
3170
3166
  });
3171
3167
  }
@@ -3174,7 +3170,7 @@ const de_CreateMultipartUploadCommand = async (output, context) => {
3174
3170
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3175
3171
  return de_CreateMultipartUploadCommandError(output, context);
3176
3172
  }
3177
- const contents = map({
3173
+ const contents = (0, smithy_client_1.map)({
3178
3174
  $metadata: deserializeMetadata(output),
3179
3175
  AbortDate: [
3180
3176
  () => void 0 !== output.headers["x-amz-abort-date"],
@@ -3213,10 +3209,9 @@ const de_CreateMultipartUploadCommandError = async (output, context) => {
3213
3209
  };
3214
3210
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3215
3211
  const parsedBody = parsedOutput.body;
3216
- (0, smithy_client_1.throwDefaultError)({
3212
+ return throwDefaultError({
3217
3213
  output,
3218
3214
  parsedBody,
3219
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3220
3215
  errorCode,
3221
3216
  });
3222
3217
  };
@@ -3224,7 +3219,7 @@ const de_DeleteBucketCommand = async (output, context) => {
3224
3219
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3225
3220
  return de_DeleteBucketCommandError(output, context);
3226
3221
  }
3227
- const contents = map({
3222
+ const contents = (0, smithy_client_1.map)({
3228
3223
  $metadata: deserializeMetadata(output),
3229
3224
  });
3230
3225
  await collectBody(output.body, context);
@@ -3238,10 +3233,9 @@ const de_DeleteBucketCommandError = async (output, context) => {
3238
3233
  };
3239
3234
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3240
3235
  const parsedBody = parsedOutput.body;
3241
- (0, smithy_client_1.throwDefaultError)({
3236
+ return throwDefaultError({
3242
3237
  output,
3243
3238
  parsedBody,
3244
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3245
3239
  errorCode,
3246
3240
  });
3247
3241
  };
@@ -3249,7 +3243,7 @@ const de_DeleteBucketAnalyticsConfigurationCommand = async (output, context) =>
3249
3243
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3250
3244
  return de_DeleteBucketAnalyticsConfigurationCommandError(output, context);
3251
3245
  }
3252
- const contents = map({
3246
+ const contents = (0, smithy_client_1.map)({
3253
3247
  $metadata: deserializeMetadata(output),
3254
3248
  });
3255
3249
  await collectBody(output.body, context);
@@ -3263,10 +3257,9 @@ const de_DeleteBucketAnalyticsConfigurationCommandError = async (output, context
3263
3257
  };
3264
3258
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3265
3259
  const parsedBody = parsedOutput.body;
3266
- (0, smithy_client_1.throwDefaultError)({
3260
+ return throwDefaultError({
3267
3261
  output,
3268
3262
  parsedBody,
3269
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3270
3263
  errorCode,
3271
3264
  });
3272
3265
  };
@@ -3274,7 +3267,7 @@ const de_DeleteBucketCorsCommand = async (output, context) => {
3274
3267
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3275
3268
  return de_DeleteBucketCorsCommandError(output, context);
3276
3269
  }
3277
- const contents = map({
3270
+ const contents = (0, smithy_client_1.map)({
3278
3271
  $metadata: deserializeMetadata(output),
3279
3272
  });
3280
3273
  await collectBody(output.body, context);
@@ -3288,10 +3281,9 @@ const de_DeleteBucketCorsCommandError = async (output, context) => {
3288
3281
  };
3289
3282
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3290
3283
  const parsedBody = parsedOutput.body;
3291
- (0, smithy_client_1.throwDefaultError)({
3284
+ return throwDefaultError({
3292
3285
  output,
3293
3286
  parsedBody,
3294
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3295
3287
  errorCode,
3296
3288
  });
3297
3289
  };
@@ -3299,7 +3291,7 @@ const de_DeleteBucketEncryptionCommand = async (output, context) => {
3299
3291
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3300
3292
  return de_DeleteBucketEncryptionCommandError(output, context);
3301
3293
  }
3302
- const contents = map({
3294
+ const contents = (0, smithy_client_1.map)({
3303
3295
  $metadata: deserializeMetadata(output),
3304
3296
  });
3305
3297
  await collectBody(output.body, context);
@@ -3313,10 +3305,9 @@ const de_DeleteBucketEncryptionCommandError = async (output, context) => {
3313
3305
  };
3314
3306
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3315
3307
  const parsedBody = parsedOutput.body;
3316
- (0, smithy_client_1.throwDefaultError)({
3308
+ return throwDefaultError({
3317
3309
  output,
3318
3310
  parsedBody,
3319
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3320
3311
  errorCode,
3321
3312
  });
3322
3313
  };
@@ -3324,7 +3315,7 @@ const de_DeleteBucketIntelligentTieringConfigurationCommand = async (output, con
3324
3315
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3325
3316
  return de_DeleteBucketIntelligentTieringConfigurationCommandError(output, context);
3326
3317
  }
3327
- const contents = map({
3318
+ const contents = (0, smithy_client_1.map)({
3328
3319
  $metadata: deserializeMetadata(output),
3329
3320
  });
3330
3321
  await collectBody(output.body, context);
@@ -3338,10 +3329,9 @@ const de_DeleteBucketIntelligentTieringConfigurationCommandError = async (output
3338
3329
  };
3339
3330
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3340
3331
  const parsedBody = parsedOutput.body;
3341
- (0, smithy_client_1.throwDefaultError)({
3332
+ return throwDefaultError({
3342
3333
  output,
3343
3334
  parsedBody,
3344
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3345
3335
  errorCode,
3346
3336
  });
3347
3337
  };
@@ -3349,7 +3339,7 @@ const de_DeleteBucketInventoryConfigurationCommand = async (output, context) =>
3349
3339
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3350
3340
  return de_DeleteBucketInventoryConfigurationCommandError(output, context);
3351
3341
  }
3352
- const contents = map({
3342
+ const contents = (0, smithy_client_1.map)({
3353
3343
  $metadata: deserializeMetadata(output),
3354
3344
  });
3355
3345
  await collectBody(output.body, context);
@@ -3363,10 +3353,9 @@ const de_DeleteBucketInventoryConfigurationCommandError = async (output, context
3363
3353
  };
3364
3354
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3365
3355
  const parsedBody = parsedOutput.body;
3366
- (0, smithy_client_1.throwDefaultError)({
3356
+ return throwDefaultError({
3367
3357
  output,
3368
3358
  parsedBody,
3369
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3370
3359
  errorCode,
3371
3360
  });
3372
3361
  };
@@ -3374,7 +3363,7 @@ const de_DeleteBucketLifecycleCommand = async (output, context) => {
3374
3363
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3375
3364
  return de_DeleteBucketLifecycleCommandError(output, context);
3376
3365
  }
3377
- const contents = map({
3366
+ const contents = (0, smithy_client_1.map)({
3378
3367
  $metadata: deserializeMetadata(output),
3379
3368
  });
3380
3369
  await collectBody(output.body, context);
@@ -3388,10 +3377,9 @@ const de_DeleteBucketLifecycleCommandError = async (output, context) => {
3388
3377
  };
3389
3378
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3390
3379
  const parsedBody = parsedOutput.body;
3391
- (0, smithy_client_1.throwDefaultError)({
3380
+ return throwDefaultError({
3392
3381
  output,
3393
3382
  parsedBody,
3394
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3395
3383
  errorCode,
3396
3384
  });
3397
3385
  };
@@ -3399,7 +3387,7 @@ const de_DeleteBucketMetricsConfigurationCommand = async (output, context) => {
3399
3387
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3400
3388
  return de_DeleteBucketMetricsConfigurationCommandError(output, context);
3401
3389
  }
3402
- const contents = map({
3390
+ const contents = (0, smithy_client_1.map)({
3403
3391
  $metadata: deserializeMetadata(output),
3404
3392
  });
3405
3393
  await collectBody(output.body, context);
@@ -3413,10 +3401,9 @@ const de_DeleteBucketMetricsConfigurationCommandError = async (output, context)
3413
3401
  };
3414
3402
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3415
3403
  const parsedBody = parsedOutput.body;
3416
- (0, smithy_client_1.throwDefaultError)({
3404
+ return throwDefaultError({
3417
3405
  output,
3418
3406
  parsedBody,
3419
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3420
3407
  errorCode,
3421
3408
  });
3422
3409
  };
@@ -3424,7 +3411,7 @@ const de_DeleteBucketOwnershipControlsCommand = async (output, context) => {
3424
3411
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3425
3412
  return de_DeleteBucketOwnershipControlsCommandError(output, context);
3426
3413
  }
3427
- const contents = map({
3414
+ const contents = (0, smithy_client_1.map)({
3428
3415
  $metadata: deserializeMetadata(output),
3429
3416
  });
3430
3417
  await collectBody(output.body, context);
@@ -3438,10 +3425,9 @@ const de_DeleteBucketOwnershipControlsCommandError = async (output, context) =>
3438
3425
  };
3439
3426
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3440
3427
  const parsedBody = parsedOutput.body;
3441
- (0, smithy_client_1.throwDefaultError)({
3428
+ return throwDefaultError({
3442
3429
  output,
3443
3430
  parsedBody,
3444
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3445
3431
  errorCode,
3446
3432
  });
3447
3433
  };
@@ -3449,7 +3435,7 @@ const de_DeleteBucketPolicyCommand = async (output, context) => {
3449
3435
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3450
3436
  return de_DeleteBucketPolicyCommandError(output, context);
3451
3437
  }
3452
- const contents = map({
3438
+ const contents = (0, smithy_client_1.map)({
3453
3439
  $metadata: deserializeMetadata(output),
3454
3440
  });
3455
3441
  await collectBody(output.body, context);
@@ -3463,10 +3449,9 @@ const de_DeleteBucketPolicyCommandError = async (output, context) => {
3463
3449
  };
3464
3450
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3465
3451
  const parsedBody = parsedOutput.body;
3466
- (0, smithy_client_1.throwDefaultError)({
3452
+ return throwDefaultError({
3467
3453
  output,
3468
3454
  parsedBody,
3469
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3470
3455
  errorCode,
3471
3456
  });
3472
3457
  };
@@ -3474,7 +3459,7 @@ const de_DeleteBucketReplicationCommand = async (output, context) => {
3474
3459
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3475
3460
  return de_DeleteBucketReplicationCommandError(output, context);
3476
3461
  }
3477
- const contents = map({
3462
+ const contents = (0, smithy_client_1.map)({
3478
3463
  $metadata: deserializeMetadata(output),
3479
3464
  });
3480
3465
  await collectBody(output.body, context);
@@ -3488,10 +3473,9 @@ const de_DeleteBucketReplicationCommandError = async (output, context) => {
3488
3473
  };
3489
3474
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3490
3475
  const parsedBody = parsedOutput.body;
3491
- (0, smithy_client_1.throwDefaultError)({
3476
+ return throwDefaultError({
3492
3477
  output,
3493
3478
  parsedBody,
3494
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3495
3479
  errorCode,
3496
3480
  });
3497
3481
  };
@@ -3499,7 +3483,7 @@ const de_DeleteBucketTaggingCommand = async (output, context) => {
3499
3483
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3500
3484
  return de_DeleteBucketTaggingCommandError(output, context);
3501
3485
  }
3502
- const contents = map({
3486
+ const contents = (0, smithy_client_1.map)({
3503
3487
  $metadata: deserializeMetadata(output),
3504
3488
  });
3505
3489
  await collectBody(output.body, context);
@@ -3513,10 +3497,9 @@ const de_DeleteBucketTaggingCommandError = async (output, context) => {
3513
3497
  };
3514
3498
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3515
3499
  const parsedBody = parsedOutput.body;
3516
- (0, smithy_client_1.throwDefaultError)({
3500
+ return throwDefaultError({
3517
3501
  output,
3518
3502
  parsedBody,
3519
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3520
3503
  errorCode,
3521
3504
  });
3522
3505
  };
@@ -3524,7 +3507,7 @@ const de_DeleteBucketWebsiteCommand = async (output, context) => {
3524
3507
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3525
3508
  return de_DeleteBucketWebsiteCommandError(output, context);
3526
3509
  }
3527
- const contents = map({
3510
+ const contents = (0, smithy_client_1.map)({
3528
3511
  $metadata: deserializeMetadata(output),
3529
3512
  });
3530
3513
  await collectBody(output.body, context);
@@ -3538,10 +3521,9 @@ const de_DeleteBucketWebsiteCommandError = async (output, context) => {
3538
3521
  };
3539
3522
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3540
3523
  const parsedBody = parsedOutput.body;
3541
- (0, smithy_client_1.throwDefaultError)({
3524
+ return throwDefaultError({
3542
3525
  output,
3543
3526
  parsedBody,
3544
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3545
3527
  errorCode,
3546
3528
  });
3547
3529
  };
@@ -3549,7 +3531,7 @@ const de_DeleteObjectCommand = async (output, context) => {
3549
3531
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3550
3532
  return de_DeleteObjectCommandError(output, context);
3551
3533
  }
3552
- const contents = map({
3534
+ const contents = (0, smithy_client_1.map)({
3553
3535
  $metadata: deserializeMetadata(output),
3554
3536
  DeleteMarker: [
3555
3537
  () => void 0 !== output.headers["x-amz-delete-marker"],
@@ -3569,10 +3551,9 @@ const de_DeleteObjectCommandError = async (output, context) => {
3569
3551
  };
3570
3552
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3571
3553
  const parsedBody = parsedOutput.body;
3572
- (0, smithy_client_1.throwDefaultError)({
3554
+ return throwDefaultError({
3573
3555
  output,
3574
3556
  parsedBody,
3575
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3576
3557
  errorCode,
3577
3558
  });
3578
3559
  };
@@ -3580,7 +3561,7 @@ const de_DeleteObjectsCommand = async (output, context) => {
3580
3561
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3581
3562
  return de_DeleteObjectsCommandError(output, context);
3582
3563
  }
3583
- const contents = map({
3564
+ const contents = (0, smithy_client_1.map)({
3584
3565
  $metadata: deserializeMetadata(output),
3585
3566
  RequestCharged: [, output.headers["x-amz-request-charged"]],
3586
3567
  });
@@ -3607,10 +3588,9 @@ const de_DeleteObjectsCommandError = async (output, context) => {
3607
3588
  };
3608
3589
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3609
3590
  const parsedBody = parsedOutput.body;
3610
- (0, smithy_client_1.throwDefaultError)({
3591
+ return throwDefaultError({
3611
3592
  output,
3612
3593
  parsedBody,
3613
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3614
3594
  errorCode,
3615
3595
  });
3616
3596
  };
@@ -3618,7 +3598,7 @@ const de_DeleteObjectTaggingCommand = async (output, context) => {
3618
3598
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3619
3599
  return de_DeleteObjectTaggingCommandError(output, context);
3620
3600
  }
3621
- const contents = map({
3601
+ const contents = (0, smithy_client_1.map)({
3622
3602
  $metadata: deserializeMetadata(output),
3623
3603
  VersionId: [, output.headers["x-amz-version-id"]],
3624
3604
  });
@@ -3633,10 +3613,9 @@ const de_DeleteObjectTaggingCommandError = async (output, context) => {
3633
3613
  };
3634
3614
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3635
3615
  const parsedBody = parsedOutput.body;
3636
- (0, smithy_client_1.throwDefaultError)({
3616
+ return throwDefaultError({
3637
3617
  output,
3638
3618
  parsedBody,
3639
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3640
3619
  errorCode,
3641
3620
  });
3642
3621
  };
@@ -3644,7 +3623,7 @@ const de_DeletePublicAccessBlockCommand = async (output, context) => {
3644
3623
  if (output.statusCode !== 204 && output.statusCode >= 300) {
3645
3624
  return de_DeletePublicAccessBlockCommandError(output, context);
3646
3625
  }
3647
- const contents = map({
3626
+ const contents = (0, smithy_client_1.map)({
3648
3627
  $metadata: deserializeMetadata(output),
3649
3628
  });
3650
3629
  await collectBody(output.body, context);
@@ -3658,10 +3637,9 @@ const de_DeletePublicAccessBlockCommandError = async (output, context) => {
3658
3637
  };
3659
3638
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3660
3639
  const parsedBody = parsedOutput.body;
3661
- (0, smithy_client_1.throwDefaultError)({
3640
+ return throwDefaultError({
3662
3641
  output,
3663
3642
  parsedBody,
3664
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3665
3643
  errorCode,
3666
3644
  });
3667
3645
  };
@@ -3669,7 +3647,7 @@ const de_GetBucketAccelerateConfigurationCommand = async (output, context) => {
3669
3647
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3670
3648
  return de_GetBucketAccelerateConfigurationCommandError(output, context);
3671
3649
  }
3672
- const contents = map({
3650
+ const contents = (0, smithy_client_1.map)({
3673
3651
  $metadata: deserializeMetadata(output),
3674
3652
  });
3675
3653
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -3686,10 +3664,9 @@ const de_GetBucketAccelerateConfigurationCommandError = async (output, context)
3686
3664
  };
3687
3665
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3688
3666
  const parsedBody = parsedOutput.body;
3689
- (0, smithy_client_1.throwDefaultError)({
3667
+ return throwDefaultError({
3690
3668
  output,
3691
3669
  parsedBody,
3692
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3693
3670
  errorCode,
3694
3671
  });
3695
3672
  };
@@ -3697,7 +3674,7 @@ const de_GetBucketAclCommand = async (output, context) => {
3697
3674
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3698
3675
  return de_GetBucketAclCommandError(output, context);
3699
3676
  }
3700
- const contents = map({
3677
+ const contents = (0, smithy_client_1.map)({
3701
3678
  $metadata: deserializeMetadata(output),
3702
3679
  });
3703
3680
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -3720,10 +3697,9 @@ const de_GetBucketAclCommandError = async (output, context) => {
3720
3697
  };
3721
3698
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3722
3699
  const parsedBody = parsedOutput.body;
3723
- (0, smithy_client_1.throwDefaultError)({
3700
+ return throwDefaultError({
3724
3701
  output,
3725
3702
  parsedBody,
3726
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3727
3703
  errorCode,
3728
3704
  });
3729
3705
  };
@@ -3731,7 +3707,7 @@ const de_GetBucketAnalyticsConfigurationCommand = async (output, context) => {
3731
3707
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3732
3708
  return de_GetBucketAnalyticsConfigurationCommandError(output, context);
3733
3709
  }
3734
- const contents = map({
3710
+ const contents = (0, smithy_client_1.map)({
3735
3711
  $metadata: deserializeMetadata(output),
3736
3712
  });
3737
3713
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
@@ -3746,10 +3722,9 @@ const de_GetBucketAnalyticsConfigurationCommandError = async (output, context) =
3746
3722
  };
3747
3723
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3748
3724
  const parsedBody = parsedOutput.body;
3749
- (0, smithy_client_1.throwDefaultError)({
3725
+ return throwDefaultError({
3750
3726
  output,
3751
3727
  parsedBody,
3752
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3753
3728
  errorCode,
3754
3729
  });
3755
3730
  };
@@ -3757,7 +3732,7 @@ const de_GetBucketCorsCommand = async (output, context) => {
3757
3732
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3758
3733
  return de_GetBucketCorsCommandError(output, context);
3759
3734
  }
3760
- const contents = map({
3735
+ const contents = (0, smithy_client_1.map)({
3761
3736
  $metadata: deserializeMetadata(output),
3762
3737
  });
3763
3738
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -3777,10 +3752,9 @@ const de_GetBucketCorsCommandError = async (output, context) => {
3777
3752
  };
3778
3753
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3779
3754
  const parsedBody = parsedOutput.body;
3780
- (0, smithy_client_1.throwDefaultError)({
3755
+ return throwDefaultError({
3781
3756
  output,
3782
3757
  parsedBody,
3783
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3784
3758
  errorCode,
3785
3759
  });
3786
3760
  };
@@ -3788,7 +3762,7 @@ const de_GetBucketEncryptionCommand = async (output, context) => {
3788
3762
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3789
3763
  return de_GetBucketEncryptionCommandError(output, context);
3790
3764
  }
3791
- const contents = map({
3765
+ const contents = (0, smithy_client_1.map)({
3792
3766
  $metadata: deserializeMetadata(output),
3793
3767
  });
3794
3768
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
@@ -3803,10 +3777,9 @@ const de_GetBucketEncryptionCommandError = async (output, context) => {
3803
3777
  };
3804
3778
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3805
3779
  const parsedBody = parsedOutput.body;
3806
- (0, smithy_client_1.throwDefaultError)({
3780
+ return throwDefaultError({
3807
3781
  output,
3808
3782
  parsedBody,
3809
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3810
3783
  errorCode,
3811
3784
  });
3812
3785
  };
@@ -3814,7 +3787,7 @@ const de_GetBucketIntelligentTieringConfigurationCommand = async (output, contex
3814
3787
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3815
3788
  return de_GetBucketIntelligentTieringConfigurationCommandError(output, context);
3816
3789
  }
3817
- const contents = map({
3790
+ const contents = (0, smithy_client_1.map)({
3818
3791
  $metadata: deserializeMetadata(output),
3819
3792
  });
3820
3793
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
@@ -3829,10 +3802,9 @@ const de_GetBucketIntelligentTieringConfigurationCommandError = async (output, c
3829
3802
  };
3830
3803
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3831
3804
  const parsedBody = parsedOutput.body;
3832
- (0, smithy_client_1.throwDefaultError)({
3805
+ return throwDefaultError({
3833
3806
  output,
3834
3807
  parsedBody,
3835
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3836
3808
  errorCode,
3837
3809
  });
3838
3810
  };
@@ -3840,7 +3812,7 @@ const de_GetBucketInventoryConfigurationCommand = async (output, context) => {
3840
3812
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3841
3813
  return de_GetBucketInventoryConfigurationCommandError(output, context);
3842
3814
  }
3843
- const contents = map({
3815
+ const contents = (0, smithy_client_1.map)({
3844
3816
  $metadata: deserializeMetadata(output),
3845
3817
  });
3846
3818
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
@@ -3855,10 +3827,9 @@ const de_GetBucketInventoryConfigurationCommandError = async (output, context) =
3855
3827
  };
3856
3828
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3857
3829
  const parsedBody = parsedOutput.body;
3858
- (0, smithy_client_1.throwDefaultError)({
3830
+ return throwDefaultError({
3859
3831
  output,
3860
3832
  parsedBody,
3861
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3862
3833
  errorCode,
3863
3834
  });
3864
3835
  };
@@ -3866,7 +3837,7 @@ const de_GetBucketLifecycleConfigurationCommand = async (output, context) => {
3866
3837
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3867
3838
  return de_GetBucketLifecycleConfigurationCommandError(output, context);
3868
3839
  }
3869
- const contents = map({
3840
+ const contents = (0, smithy_client_1.map)({
3870
3841
  $metadata: deserializeMetadata(output),
3871
3842
  });
3872
3843
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -3886,10 +3857,9 @@ const de_GetBucketLifecycleConfigurationCommandError = async (output, context) =
3886
3857
  };
3887
3858
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3888
3859
  const parsedBody = parsedOutput.body;
3889
- (0, smithy_client_1.throwDefaultError)({
3860
+ return throwDefaultError({
3890
3861
  output,
3891
3862
  parsedBody,
3892
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3893
3863
  errorCode,
3894
3864
  });
3895
3865
  };
@@ -3897,7 +3867,7 @@ const de_GetBucketLocationCommand = async (output, context) => {
3897
3867
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3898
3868
  return de_GetBucketLocationCommandError(output, context);
3899
3869
  }
3900
- const contents = map({
3870
+ const contents = (0, smithy_client_1.map)({
3901
3871
  $metadata: deserializeMetadata(output),
3902
3872
  });
3903
3873
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -3914,10 +3884,9 @@ const de_GetBucketLocationCommandError = async (output, context) => {
3914
3884
  };
3915
3885
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3916
3886
  const parsedBody = parsedOutput.body;
3917
- (0, smithy_client_1.throwDefaultError)({
3887
+ return throwDefaultError({
3918
3888
  output,
3919
3889
  parsedBody,
3920
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3921
3890
  errorCode,
3922
3891
  });
3923
3892
  };
@@ -3925,7 +3894,7 @@ const de_GetBucketLoggingCommand = async (output, context) => {
3925
3894
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3926
3895
  return de_GetBucketLoggingCommandError(output, context);
3927
3896
  }
3928
- const contents = map({
3897
+ const contents = (0, smithy_client_1.map)({
3929
3898
  $metadata: deserializeMetadata(output),
3930
3899
  });
3931
3900
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -3942,10 +3911,9 @@ const de_GetBucketLoggingCommandError = async (output, context) => {
3942
3911
  };
3943
3912
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3944
3913
  const parsedBody = parsedOutput.body;
3945
- (0, smithy_client_1.throwDefaultError)({
3914
+ return throwDefaultError({
3946
3915
  output,
3947
3916
  parsedBody,
3948
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3949
3917
  errorCode,
3950
3918
  });
3951
3919
  };
@@ -3953,7 +3921,7 @@ const de_GetBucketMetricsConfigurationCommand = async (output, context) => {
3953
3921
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3954
3922
  return de_GetBucketMetricsConfigurationCommandError(output, context);
3955
3923
  }
3956
- const contents = map({
3924
+ const contents = (0, smithy_client_1.map)({
3957
3925
  $metadata: deserializeMetadata(output),
3958
3926
  });
3959
3927
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
@@ -3968,10 +3936,9 @@ const de_GetBucketMetricsConfigurationCommandError = async (output, context) =>
3968
3936
  };
3969
3937
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
3970
3938
  const parsedBody = parsedOutput.body;
3971
- (0, smithy_client_1.throwDefaultError)({
3939
+ return throwDefaultError({
3972
3940
  output,
3973
3941
  parsedBody,
3974
- exceptionCtor: S3ServiceException_1.S3ServiceException,
3975
3942
  errorCode,
3976
3943
  });
3977
3944
  };
@@ -3979,7 +3946,7 @@ const de_GetBucketNotificationConfigurationCommand = async (output, context) =>
3979
3946
  if (output.statusCode !== 200 && output.statusCode >= 300) {
3980
3947
  return de_GetBucketNotificationConfigurationCommandError(output, context);
3981
3948
  }
3982
- const contents = map({
3949
+ const contents = (0, smithy_client_1.map)({
3983
3950
  $metadata: deserializeMetadata(output),
3984
3951
  });
3985
3952
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -4014,10 +3981,9 @@ const de_GetBucketNotificationConfigurationCommandError = async (output, context
4014
3981
  };
4015
3982
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4016
3983
  const parsedBody = parsedOutput.body;
4017
- (0, smithy_client_1.throwDefaultError)({
3984
+ return throwDefaultError({
4018
3985
  output,
4019
3986
  parsedBody,
4020
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4021
3987
  errorCode,
4022
3988
  });
4023
3989
  };
@@ -4025,7 +3991,7 @@ const de_GetBucketOwnershipControlsCommand = async (output, context) => {
4025
3991
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4026
3992
  return de_GetBucketOwnershipControlsCommandError(output, context);
4027
3993
  }
4028
- const contents = map({
3994
+ const contents = (0, smithy_client_1.map)({
4029
3995
  $metadata: deserializeMetadata(output),
4030
3996
  });
4031
3997
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
@@ -4040,10 +4006,9 @@ const de_GetBucketOwnershipControlsCommandError = async (output, context) => {
4040
4006
  };
4041
4007
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4042
4008
  const parsedBody = parsedOutput.body;
4043
- (0, smithy_client_1.throwDefaultError)({
4009
+ return throwDefaultError({
4044
4010
  output,
4045
4011
  parsedBody,
4046
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4047
4012
  errorCode,
4048
4013
  });
4049
4014
  };
@@ -4051,7 +4016,7 @@ const de_GetBucketPolicyCommand = async (output, context) => {
4051
4016
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4052
4017
  return de_GetBucketPolicyCommandError(output, context);
4053
4018
  }
4054
- const contents = map({
4019
+ const contents = (0, smithy_client_1.map)({
4055
4020
  $metadata: deserializeMetadata(output),
4056
4021
  });
4057
4022
  const data = await collectBodyString(output.body, context);
@@ -4066,10 +4031,9 @@ const de_GetBucketPolicyCommandError = async (output, context) => {
4066
4031
  };
4067
4032
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4068
4033
  const parsedBody = parsedOutput.body;
4069
- (0, smithy_client_1.throwDefaultError)({
4034
+ return throwDefaultError({
4070
4035
  output,
4071
4036
  parsedBody,
4072
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4073
4037
  errorCode,
4074
4038
  });
4075
4039
  };
@@ -4077,7 +4041,7 @@ const de_GetBucketPolicyStatusCommand = async (output, context) => {
4077
4041
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4078
4042
  return de_GetBucketPolicyStatusCommandError(output, context);
4079
4043
  }
4080
- const contents = map({
4044
+ const contents = (0, smithy_client_1.map)({
4081
4045
  $metadata: deserializeMetadata(output),
4082
4046
  });
4083
4047
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
@@ -4092,10 +4056,9 @@ const de_GetBucketPolicyStatusCommandError = async (output, context) => {
4092
4056
  };
4093
4057
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4094
4058
  const parsedBody = parsedOutput.body;
4095
- (0, smithy_client_1.throwDefaultError)({
4059
+ return throwDefaultError({
4096
4060
  output,
4097
4061
  parsedBody,
4098
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4099
4062
  errorCode,
4100
4063
  });
4101
4064
  };
@@ -4103,7 +4066,7 @@ const de_GetBucketReplicationCommand = async (output, context) => {
4103
4066
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4104
4067
  return de_GetBucketReplicationCommandError(output, context);
4105
4068
  }
4106
- const contents = map({
4069
+ const contents = (0, smithy_client_1.map)({
4107
4070
  $metadata: deserializeMetadata(output),
4108
4071
  });
4109
4072
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
@@ -4118,10 +4081,9 @@ const de_GetBucketReplicationCommandError = async (output, context) => {
4118
4081
  };
4119
4082
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4120
4083
  const parsedBody = parsedOutput.body;
4121
- (0, smithy_client_1.throwDefaultError)({
4084
+ return throwDefaultError({
4122
4085
  output,
4123
4086
  parsedBody,
4124
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4125
4087
  errorCode,
4126
4088
  });
4127
4089
  };
@@ -4129,7 +4091,7 @@ const de_GetBucketRequestPaymentCommand = async (output, context) => {
4129
4091
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4130
4092
  return de_GetBucketRequestPaymentCommandError(output, context);
4131
4093
  }
4132
- const contents = map({
4094
+ const contents = (0, smithy_client_1.map)({
4133
4095
  $metadata: deserializeMetadata(output),
4134
4096
  });
4135
4097
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -4146,10 +4108,9 @@ const de_GetBucketRequestPaymentCommandError = async (output, context) => {
4146
4108
  };
4147
4109
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4148
4110
  const parsedBody = parsedOutput.body;
4149
- (0, smithy_client_1.throwDefaultError)({
4111
+ return throwDefaultError({
4150
4112
  output,
4151
4113
  parsedBody,
4152
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4153
4114
  errorCode,
4154
4115
  });
4155
4116
  };
@@ -4157,7 +4118,7 @@ const de_GetBucketTaggingCommand = async (output, context) => {
4157
4118
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4158
4119
  return de_GetBucketTaggingCommandError(output, context);
4159
4120
  }
4160
- const contents = map({
4121
+ const contents = (0, smithy_client_1.map)({
4161
4122
  $metadata: deserializeMetadata(output),
4162
4123
  });
4163
4124
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -4177,10 +4138,9 @@ const de_GetBucketTaggingCommandError = async (output, context) => {
4177
4138
  };
4178
4139
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4179
4140
  const parsedBody = parsedOutput.body;
4180
- (0, smithy_client_1.throwDefaultError)({
4141
+ return throwDefaultError({
4181
4142
  output,
4182
4143
  parsedBody,
4183
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4184
4144
  errorCode,
4185
4145
  });
4186
4146
  };
@@ -4188,7 +4148,7 @@ const de_GetBucketVersioningCommand = async (output, context) => {
4188
4148
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4189
4149
  return de_GetBucketVersioningCommandError(output, context);
4190
4150
  }
4191
- const contents = map({
4151
+ const contents = (0, smithy_client_1.map)({
4192
4152
  $metadata: deserializeMetadata(output),
4193
4153
  });
4194
4154
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -4208,10 +4168,9 @@ const de_GetBucketVersioningCommandError = async (output, context) => {
4208
4168
  };
4209
4169
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4210
4170
  const parsedBody = parsedOutput.body;
4211
- (0, smithy_client_1.throwDefaultError)({
4171
+ return throwDefaultError({
4212
4172
  output,
4213
4173
  parsedBody,
4214
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4215
4174
  errorCode,
4216
4175
  });
4217
4176
  };
@@ -4219,7 +4178,7 @@ const de_GetBucketWebsiteCommand = async (output, context) => {
4219
4178
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4220
4179
  return de_GetBucketWebsiteCommandError(output, context);
4221
4180
  }
4222
- const contents = map({
4181
+ const contents = (0, smithy_client_1.map)({
4223
4182
  $metadata: deserializeMetadata(output),
4224
4183
  });
4225
4184
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -4248,10 +4207,9 @@ const de_GetBucketWebsiteCommandError = async (output, context) => {
4248
4207
  };
4249
4208
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4250
4209
  const parsedBody = parsedOutput.body;
4251
- (0, smithy_client_1.throwDefaultError)({
4210
+ return throwDefaultError({
4252
4211
  output,
4253
4212
  parsedBody,
4254
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4255
4213
  errorCode,
4256
4214
  });
4257
4215
  };
@@ -4259,7 +4217,7 @@ const de_GetObjectCommand = async (output, context) => {
4259
4217
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4260
4218
  return de_GetObjectCommandError(output, context);
4261
4219
  }
4262
- const contents = map({
4220
+ const contents = (0, smithy_client_1.map)({
4263
4221
  $metadata: deserializeMetadata(output),
4264
4222
  DeleteMarker: [
4265
4223
  () => void 0 !== output.headers["x-amz-delete-marker"],
@@ -4353,10 +4311,9 @@ const de_GetObjectCommandError = async (output, context) => {
4353
4311
  throw await de_NoSuchKeyRes(parsedOutput, context);
4354
4312
  default:
4355
4313
  const parsedBody = parsedOutput.body;
4356
- (0, smithy_client_1.throwDefaultError)({
4314
+ return throwDefaultError({
4357
4315
  output,
4358
4316
  parsedBody,
4359
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4360
4317
  errorCode,
4361
4318
  });
4362
4319
  }
@@ -4365,7 +4322,7 @@ const de_GetObjectAclCommand = async (output, context) => {
4365
4322
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4366
4323
  return de_GetObjectAclCommandError(output, context);
4367
4324
  }
4368
- const contents = map({
4325
+ const contents = (0, smithy_client_1.map)({
4369
4326
  $metadata: deserializeMetadata(output),
4370
4327
  RequestCharged: [, output.headers["x-amz-request-charged"]],
4371
4328
  });
@@ -4394,10 +4351,9 @@ const de_GetObjectAclCommandError = async (output, context) => {
4394
4351
  throw await de_NoSuchKeyRes(parsedOutput, context);
4395
4352
  default:
4396
4353
  const parsedBody = parsedOutput.body;
4397
- (0, smithy_client_1.throwDefaultError)({
4354
+ return throwDefaultError({
4398
4355
  output,
4399
4356
  parsedBody,
4400
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4401
4357
  errorCode,
4402
4358
  });
4403
4359
  }
@@ -4406,7 +4362,7 @@ const de_GetObjectAttributesCommand = async (output, context) => {
4406
4362
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4407
4363
  return de_GetObjectAttributesCommandError(output, context);
4408
4364
  }
4409
- const contents = map({
4365
+ const contents = (0, smithy_client_1.map)({
4410
4366
  $metadata: deserializeMetadata(output),
4411
4367
  DeleteMarker: [
4412
4368
  () => void 0 !== output.headers["x-amz-delete-marker"],
@@ -4450,10 +4406,9 @@ const de_GetObjectAttributesCommandError = async (output, context) => {
4450
4406
  throw await de_NoSuchKeyRes(parsedOutput, context);
4451
4407
  default:
4452
4408
  const parsedBody = parsedOutput.body;
4453
- (0, smithy_client_1.throwDefaultError)({
4409
+ return throwDefaultError({
4454
4410
  output,
4455
4411
  parsedBody,
4456
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4457
4412
  errorCode,
4458
4413
  });
4459
4414
  }
@@ -4462,7 +4417,7 @@ const de_GetObjectLegalHoldCommand = async (output, context) => {
4462
4417
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4463
4418
  return de_GetObjectLegalHoldCommandError(output, context);
4464
4419
  }
4465
- const contents = map({
4420
+ const contents = (0, smithy_client_1.map)({
4466
4421
  $metadata: deserializeMetadata(output),
4467
4422
  });
4468
4423
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
@@ -4477,10 +4432,9 @@ const de_GetObjectLegalHoldCommandError = async (output, context) => {
4477
4432
  };
4478
4433
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4479
4434
  const parsedBody = parsedOutput.body;
4480
- (0, smithy_client_1.throwDefaultError)({
4435
+ return throwDefaultError({
4481
4436
  output,
4482
4437
  parsedBody,
4483
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4484
4438
  errorCode,
4485
4439
  });
4486
4440
  };
@@ -4488,7 +4442,7 @@ const de_GetObjectLockConfigurationCommand = async (output, context) => {
4488
4442
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4489
4443
  return de_GetObjectLockConfigurationCommandError(output, context);
4490
4444
  }
4491
- const contents = map({
4445
+ const contents = (0, smithy_client_1.map)({
4492
4446
  $metadata: deserializeMetadata(output),
4493
4447
  });
4494
4448
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
@@ -4503,10 +4457,9 @@ const de_GetObjectLockConfigurationCommandError = async (output, context) => {
4503
4457
  };
4504
4458
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4505
4459
  const parsedBody = parsedOutput.body;
4506
- (0, smithy_client_1.throwDefaultError)({
4460
+ return throwDefaultError({
4507
4461
  output,
4508
4462
  parsedBody,
4509
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4510
4463
  errorCode,
4511
4464
  });
4512
4465
  };
@@ -4514,7 +4467,7 @@ const de_GetObjectRetentionCommand = async (output, context) => {
4514
4467
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4515
4468
  return de_GetObjectRetentionCommandError(output, context);
4516
4469
  }
4517
- const contents = map({
4470
+ const contents = (0, smithy_client_1.map)({
4518
4471
  $metadata: deserializeMetadata(output),
4519
4472
  });
4520
4473
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
@@ -4529,10 +4482,9 @@ const de_GetObjectRetentionCommandError = async (output, context) => {
4529
4482
  };
4530
4483
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4531
4484
  const parsedBody = parsedOutput.body;
4532
- (0, smithy_client_1.throwDefaultError)({
4485
+ return throwDefaultError({
4533
4486
  output,
4534
4487
  parsedBody,
4535
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4536
4488
  errorCode,
4537
4489
  });
4538
4490
  };
@@ -4540,7 +4492,7 @@ const de_GetObjectTaggingCommand = async (output, context) => {
4540
4492
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4541
4493
  return de_GetObjectTaggingCommandError(output, context);
4542
4494
  }
4543
- const contents = map({
4495
+ const contents = (0, smithy_client_1.map)({
4544
4496
  $metadata: deserializeMetadata(output),
4545
4497
  VersionId: [, output.headers["x-amz-version-id"]],
4546
4498
  });
@@ -4561,10 +4513,9 @@ const de_GetObjectTaggingCommandError = async (output, context) => {
4561
4513
  };
4562
4514
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4563
4515
  const parsedBody = parsedOutput.body;
4564
- (0, smithy_client_1.throwDefaultError)({
4516
+ return throwDefaultError({
4565
4517
  output,
4566
4518
  parsedBody,
4567
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4568
4519
  errorCode,
4569
4520
  });
4570
4521
  };
@@ -4572,7 +4523,7 @@ const de_GetObjectTorrentCommand = async (output, context) => {
4572
4523
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4573
4524
  return de_GetObjectTorrentCommandError(output, context);
4574
4525
  }
4575
- const contents = map({
4526
+ const contents = (0, smithy_client_1.map)({
4576
4527
  $metadata: deserializeMetadata(output),
4577
4528
  RequestCharged: [, output.headers["x-amz-request-charged"]],
4578
4529
  });
@@ -4589,10 +4540,9 @@ const de_GetObjectTorrentCommandError = async (output, context) => {
4589
4540
  };
4590
4541
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4591
4542
  const parsedBody = parsedOutput.body;
4592
- (0, smithy_client_1.throwDefaultError)({
4543
+ return throwDefaultError({
4593
4544
  output,
4594
4545
  parsedBody,
4595
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4596
4546
  errorCode,
4597
4547
  });
4598
4548
  };
@@ -4600,7 +4550,7 @@ const de_GetPublicAccessBlockCommand = async (output, context) => {
4600
4550
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4601
4551
  return de_GetPublicAccessBlockCommandError(output, context);
4602
4552
  }
4603
- const contents = map({
4553
+ const contents = (0, smithy_client_1.map)({
4604
4554
  $metadata: deserializeMetadata(output),
4605
4555
  });
4606
4556
  const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context));
@@ -4615,10 +4565,9 @@ const de_GetPublicAccessBlockCommandError = async (output, context) => {
4615
4565
  };
4616
4566
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4617
4567
  const parsedBody = parsedOutput.body;
4618
- (0, smithy_client_1.throwDefaultError)({
4568
+ return throwDefaultError({
4619
4569
  output,
4620
4570
  parsedBody,
4621
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4622
4571
  errorCode,
4623
4572
  });
4624
4573
  };
@@ -4626,7 +4575,7 @@ const de_HeadBucketCommand = async (output, context) => {
4626
4575
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4627
4576
  return de_HeadBucketCommandError(output, context);
4628
4577
  }
4629
- const contents = map({
4578
+ const contents = (0, smithy_client_1.map)({
4630
4579
  $metadata: deserializeMetadata(output),
4631
4580
  });
4632
4581
  await collectBody(output.body, context);
@@ -4645,10 +4594,9 @@ const de_HeadBucketCommandError = async (output, context) => {
4645
4594
  throw await de_NotFoundRes(parsedOutput, context);
4646
4595
  default:
4647
4596
  const parsedBody = parsedOutput.body;
4648
- (0, smithy_client_1.throwDefaultError)({
4597
+ return throwDefaultError({
4649
4598
  output,
4650
4599
  parsedBody,
4651
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4652
4600
  errorCode,
4653
4601
  });
4654
4602
  }
@@ -4657,7 +4605,7 @@ const de_HeadObjectCommand = async (output, context) => {
4657
4605
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4658
4606
  return de_HeadObjectCommandError(output, context);
4659
4607
  }
4660
- const contents = map({
4608
+ const contents = (0, smithy_client_1.map)({
4661
4609
  $metadata: deserializeMetadata(output),
4662
4610
  DeleteMarker: [
4663
4611
  () => void 0 !== output.headers["x-amz-delete-marker"],
@@ -4742,10 +4690,9 @@ const de_HeadObjectCommandError = async (output, context) => {
4742
4690
  throw await de_NotFoundRes(parsedOutput, context);
4743
4691
  default:
4744
4692
  const parsedBody = parsedOutput.body;
4745
- (0, smithy_client_1.throwDefaultError)({
4693
+ return throwDefaultError({
4746
4694
  output,
4747
4695
  parsedBody,
4748
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4749
4696
  errorCode,
4750
4697
  });
4751
4698
  }
@@ -4754,7 +4701,7 @@ const de_ListBucketAnalyticsConfigurationsCommand = async (output, context) => {
4754
4701
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4755
4702
  return de_ListBucketAnalyticsConfigurationsCommandError(output, context);
4756
4703
  }
4757
- const contents = map({
4704
+ const contents = (0, smithy_client_1.map)({
4758
4705
  $metadata: deserializeMetadata(output),
4759
4706
  });
4760
4707
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -4783,10 +4730,9 @@ const de_ListBucketAnalyticsConfigurationsCommandError = async (output, context)
4783
4730
  };
4784
4731
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4785
4732
  const parsedBody = parsedOutput.body;
4786
- (0, smithy_client_1.throwDefaultError)({
4733
+ return throwDefaultError({
4787
4734
  output,
4788
4735
  parsedBody,
4789
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4790
4736
  errorCode,
4791
4737
  });
4792
4738
  };
@@ -4794,7 +4740,7 @@ const de_ListBucketIntelligentTieringConfigurationsCommand = async (output, cont
4794
4740
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4795
4741
  return de_ListBucketIntelligentTieringConfigurationsCommandError(output, context);
4796
4742
  }
4797
- const contents = map({
4743
+ const contents = (0, smithy_client_1.map)({
4798
4744
  $metadata: deserializeMetadata(output),
4799
4745
  });
4800
4746
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -4823,10 +4769,9 @@ const de_ListBucketIntelligentTieringConfigurationsCommandError = async (output,
4823
4769
  };
4824
4770
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4825
4771
  const parsedBody = parsedOutput.body;
4826
- (0, smithy_client_1.throwDefaultError)({
4772
+ return throwDefaultError({
4827
4773
  output,
4828
4774
  parsedBody,
4829
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4830
4775
  errorCode,
4831
4776
  });
4832
4777
  };
@@ -4834,7 +4779,7 @@ const de_ListBucketInventoryConfigurationsCommand = async (output, context) => {
4834
4779
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4835
4780
  return de_ListBucketInventoryConfigurationsCommandError(output, context);
4836
4781
  }
4837
- const contents = map({
4782
+ const contents = (0, smithy_client_1.map)({
4838
4783
  $metadata: deserializeMetadata(output),
4839
4784
  });
4840
4785
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -4863,10 +4808,9 @@ const de_ListBucketInventoryConfigurationsCommandError = async (output, context)
4863
4808
  };
4864
4809
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4865
4810
  const parsedBody = parsedOutput.body;
4866
- (0, smithy_client_1.throwDefaultError)({
4811
+ return throwDefaultError({
4867
4812
  output,
4868
4813
  parsedBody,
4869
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4870
4814
  errorCode,
4871
4815
  });
4872
4816
  };
@@ -4874,7 +4818,7 @@ const de_ListBucketMetricsConfigurationsCommand = async (output, context) => {
4874
4818
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4875
4819
  return de_ListBucketMetricsConfigurationsCommandError(output, context);
4876
4820
  }
4877
- const contents = map({
4821
+ const contents = (0, smithy_client_1.map)({
4878
4822
  $metadata: deserializeMetadata(output),
4879
4823
  });
4880
4824
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -4903,10 +4847,9 @@ const de_ListBucketMetricsConfigurationsCommandError = async (output, context) =
4903
4847
  };
4904
4848
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4905
4849
  const parsedBody = parsedOutput.body;
4906
- (0, smithy_client_1.throwDefaultError)({
4850
+ return throwDefaultError({
4907
4851
  output,
4908
4852
  parsedBody,
4909
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4910
4853
  errorCode,
4911
4854
  });
4912
4855
  };
@@ -4914,7 +4857,7 @@ const de_ListBucketsCommand = async (output, context) => {
4914
4857
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4915
4858
  return de_ListBucketsCommandError(output, context);
4916
4859
  }
4917
- const contents = map({
4860
+ const contents = (0, smithy_client_1.map)({
4918
4861
  $metadata: deserializeMetadata(output),
4919
4862
  });
4920
4863
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -4937,10 +4880,9 @@ const de_ListBucketsCommandError = async (output, context) => {
4937
4880
  };
4938
4881
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
4939
4882
  const parsedBody = parsedOutput.body;
4940
- (0, smithy_client_1.throwDefaultError)({
4883
+ return throwDefaultError({
4941
4884
  output,
4942
4885
  parsedBody,
4943
- exceptionCtor: S3ServiceException_1.S3ServiceException,
4944
4886
  errorCode,
4945
4887
  });
4946
4888
  };
@@ -4948,7 +4890,7 @@ const de_ListMultipartUploadsCommand = async (output, context) => {
4948
4890
  if (output.statusCode !== 200 && output.statusCode >= 300) {
4949
4891
  return de_ListMultipartUploadsCommandError(output, context);
4950
4892
  }
4951
- const contents = map({
4893
+ const contents = (0, smithy_client_1.map)({
4952
4894
  $metadata: deserializeMetadata(output),
4953
4895
  });
4954
4896
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -5004,10 +4946,9 @@ const de_ListMultipartUploadsCommandError = async (output, context) => {
5004
4946
  };
5005
4947
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5006
4948
  const parsedBody = parsedOutput.body;
5007
- (0, smithy_client_1.throwDefaultError)({
4949
+ return throwDefaultError({
5008
4950
  output,
5009
4951
  parsedBody,
5010
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5011
4952
  errorCode,
5012
4953
  });
5013
4954
  };
@@ -5015,7 +4956,7 @@ const de_ListObjectsCommand = async (output, context) => {
5015
4956
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5016
4957
  return de_ListObjectsCommandError(output, context);
5017
4958
  }
5018
- const contents = map({
4959
+ const contents = (0, smithy_client_1.map)({
5019
4960
  $metadata: deserializeMetadata(output),
5020
4961
  });
5021
4962
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -5070,10 +5011,9 @@ const de_ListObjectsCommandError = async (output, context) => {
5070
5011
  throw await de_NoSuchBucketRes(parsedOutput, context);
5071
5012
  default:
5072
5013
  const parsedBody = parsedOutput.body;
5073
- (0, smithy_client_1.throwDefaultError)({
5014
+ return throwDefaultError({
5074
5015
  output,
5075
5016
  parsedBody,
5076
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5077
5017
  errorCode,
5078
5018
  });
5079
5019
  }
@@ -5082,7 +5022,7 @@ const de_ListObjectsV2Command = async (output, context) => {
5082
5022
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5083
5023
  return de_ListObjectsV2CommandError(output, context);
5084
5024
  }
5085
- const contents = map({
5025
+ const contents = (0, smithy_client_1.map)({
5086
5026
  $metadata: deserializeMetadata(output),
5087
5027
  });
5088
5028
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -5143,10 +5083,9 @@ const de_ListObjectsV2CommandError = async (output, context) => {
5143
5083
  throw await de_NoSuchBucketRes(parsedOutput, context);
5144
5084
  default:
5145
5085
  const parsedBody = parsedOutput.body;
5146
- (0, smithy_client_1.throwDefaultError)({
5086
+ return throwDefaultError({
5147
5087
  output,
5148
5088
  parsedBody,
5149
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5150
5089
  errorCode,
5151
5090
  });
5152
5091
  }
@@ -5155,7 +5094,7 @@ const de_ListObjectVersionsCommand = async (output, context) => {
5155
5094
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5156
5095
  return de_ListObjectVersionsCommandError(output, context);
5157
5096
  }
5158
- const contents = map({
5097
+ const contents = (0, smithy_client_1.map)({
5159
5098
  $metadata: deserializeMetadata(output),
5160
5099
  });
5161
5100
  const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
@@ -5217,10 +5156,9 @@ const de_ListObjectVersionsCommandError = async (output, context) => {
5217
5156
  };
5218
5157
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5219
5158
  const parsedBody = parsedOutput.body;
5220
- (0, smithy_client_1.throwDefaultError)({
5159
+ return throwDefaultError({
5221
5160
  output,
5222
5161
  parsedBody,
5223
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5224
5162
  errorCode,
5225
5163
  });
5226
5164
  };
@@ -5228,7 +5166,7 @@ const de_ListPartsCommand = async (output, context) => {
5228
5166
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5229
5167
  return de_ListPartsCommandError(output, context);
5230
5168
  }
5231
- const contents = map({
5169
+ const contents = (0, smithy_client_1.map)({
5232
5170
  $metadata: deserializeMetadata(output),
5233
5171
  AbortDate: [
5234
5172
  () => void 0 !== output.headers["x-amz-abort-date"],
@@ -5287,10 +5225,9 @@ const de_ListPartsCommandError = async (output, context) => {
5287
5225
  };
5288
5226
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5289
5227
  const parsedBody = parsedOutput.body;
5290
- (0, smithy_client_1.throwDefaultError)({
5228
+ return throwDefaultError({
5291
5229
  output,
5292
5230
  parsedBody,
5293
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5294
5231
  errorCode,
5295
5232
  });
5296
5233
  };
@@ -5298,7 +5235,7 @@ const de_PutBucketAccelerateConfigurationCommand = async (output, context) => {
5298
5235
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5299
5236
  return de_PutBucketAccelerateConfigurationCommandError(output, context);
5300
5237
  }
5301
- const contents = map({
5238
+ const contents = (0, smithy_client_1.map)({
5302
5239
  $metadata: deserializeMetadata(output),
5303
5240
  });
5304
5241
  await collectBody(output.body, context);
@@ -5312,10 +5249,9 @@ const de_PutBucketAccelerateConfigurationCommandError = async (output, context)
5312
5249
  };
5313
5250
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5314
5251
  const parsedBody = parsedOutput.body;
5315
- (0, smithy_client_1.throwDefaultError)({
5252
+ return throwDefaultError({
5316
5253
  output,
5317
5254
  parsedBody,
5318
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5319
5255
  errorCode,
5320
5256
  });
5321
5257
  };
@@ -5323,7 +5259,7 @@ const de_PutBucketAclCommand = async (output, context) => {
5323
5259
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5324
5260
  return de_PutBucketAclCommandError(output, context);
5325
5261
  }
5326
- const contents = map({
5262
+ const contents = (0, smithy_client_1.map)({
5327
5263
  $metadata: deserializeMetadata(output),
5328
5264
  });
5329
5265
  await collectBody(output.body, context);
@@ -5337,10 +5273,9 @@ const de_PutBucketAclCommandError = async (output, context) => {
5337
5273
  };
5338
5274
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5339
5275
  const parsedBody = parsedOutput.body;
5340
- (0, smithy_client_1.throwDefaultError)({
5276
+ return throwDefaultError({
5341
5277
  output,
5342
5278
  parsedBody,
5343
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5344
5279
  errorCode,
5345
5280
  });
5346
5281
  };
@@ -5348,7 +5283,7 @@ const de_PutBucketAnalyticsConfigurationCommand = async (output, context) => {
5348
5283
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5349
5284
  return de_PutBucketAnalyticsConfigurationCommandError(output, context);
5350
5285
  }
5351
- const contents = map({
5286
+ const contents = (0, smithy_client_1.map)({
5352
5287
  $metadata: deserializeMetadata(output),
5353
5288
  });
5354
5289
  await collectBody(output.body, context);
@@ -5362,10 +5297,9 @@ const de_PutBucketAnalyticsConfigurationCommandError = async (output, context) =
5362
5297
  };
5363
5298
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5364
5299
  const parsedBody = parsedOutput.body;
5365
- (0, smithy_client_1.throwDefaultError)({
5300
+ return throwDefaultError({
5366
5301
  output,
5367
5302
  parsedBody,
5368
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5369
5303
  errorCode,
5370
5304
  });
5371
5305
  };
@@ -5373,7 +5307,7 @@ const de_PutBucketCorsCommand = async (output, context) => {
5373
5307
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5374
5308
  return de_PutBucketCorsCommandError(output, context);
5375
5309
  }
5376
- const contents = map({
5310
+ const contents = (0, smithy_client_1.map)({
5377
5311
  $metadata: deserializeMetadata(output),
5378
5312
  });
5379
5313
  await collectBody(output.body, context);
@@ -5387,10 +5321,9 @@ const de_PutBucketCorsCommandError = async (output, context) => {
5387
5321
  };
5388
5322
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5389
5323
  const parsedBody = parsedOutput.body;
5390
- (0, smithy_client_1.throwDefaultError)({
5324
+ return throwDefaultError({
5391
5325
  output,
5392
5326
  parsedBody,
5393
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5394
5327
  errorCode,
5395
5328
  });
5396
5329
  };
@@ -5398,7 +5331,7 @@ const de_PutBucketEncryptionCommand = async (output, context) => {
5398
5331
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5399
5332
  return de_PutBucketEncryptionCommandError(output, context);
5400
5333
  }
5401
- const contents = map({
5334
+ const contents = (0, smithy_client_1.map)({
5402
5335
  $metadata: deserializeMetadata(output),
5403
5336
  });
5404
5337
  await collectBody(output.body, context);
@@ -5412,10 +5345,9 @@ const de_PutBucketEncryptionCommandError = async (output, context) => {
5412
5345
  };
5413
5346
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5414
5347
  const parsedBody = parsedOutput.body;
5415
- (0, smithy_client_1.throwDefaultError)({
5348
+ return throwDefaultError({
5416
5349
  output,
5417
5350
  parsedBody,
5418
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5419
5351
  errorCode,
5420
5352
  });
5421
5353
  };
@@ -5423,7 +5355,7 @@ const de_PutBucketIntelligentTieringConfigurationCommand = async (output, contex
5423
5355
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5424
5356
  return de_PutBucketIntelligentTieringConfigurationCommandError(output, context);
5425
5357
  }
5426
- const contents = map({
5358
+ const contents = (0, smithy_client_1.map)({
5427
5359
  $metadata: deserializeMetadata(output),
5428
5360
  });
5429
5361
  await collectBody(output.body, context);
@@ -5437,10 +5369,9 @@ const de_PutBucketIntelligentTieringConfigurationCommandError = async (output, c
5437
5369
  };
5438
5370
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5439
5371
  const parsedBody = parsedOutput.body;
5440
- (0, smithy_client_1.throwDefaultError)({
5372
+ return throwDefaultError({
5441
5373
  output,
5442
5374
  parsedBody,
5443
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5444
5375
  errorCode,
5445
5376
  });
5446
5377
  };
@@ -5448,7 +5379,7 @@ const de_PutBucketInventoryConfigurationCommand = async (output, context) => {
5448
5379
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5449
5380
  return de_PutBucketInventoryConfigurationCommandError(output, context);
5450
5381
  }
5451
- const contents = map({
5382
+ const contents = (0, smithy_client_1.map)({
5452
5383
  $metadata: deserializeMetadata(output),
5453
5384
  });
5454
5385
  await collectBody(output.body, context);
@@ -5462,10 +5393,9 @@ const de_PutBucketInventoryConfigurationCommandError = async (output, context) =
5462
5393
  };
5463
5394
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5464
5395
  const parsedBody = parsedOutput.body;
5465
- (0, smithy_client_1.throwDefaultError)({
5396
+ return throwDefaultError({
5466
5397
  output,
5467
5398
  parsedBody,
5468
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5469
5399
  errorCode,
5470
5400
  });
5471
5401
  };
@@ -5473,7 +5403,7 @@ const de_PutBucketLifecycleConfigurationCommand = async (output, context) => {
5473
5403
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5474
5404
  return de_PutBucketLifecycleConfigurationCommandError(output, context);
5475
5405
  }
5476
- const contents = map({
5406
+ const contents = (0, smithy_client_1.map)({
5477
5407
  $metadata: deserializeMetadata(output),
5478
5408
  });
5479
5409
  await collectBody(output.body, context);
@@ -5487,10 +5417,9 @@ const de_PutBucketLifecycleConfigurationCommandError = async (output, context) =
5487
5417
  };
5488
5418
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5489
5419
  const parsedBody = parsedOutput.body;
5490
- (0, smithy_client_1.throwDefaultError)({
5420
+ return throwDefaultError({
5491
5421
  output,
5492
5422
  parsedBody,
5493
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5494
5423
  errorCode,
5495
5424
  });
5496
5425
  };
@@ -5498,7 +5427,7 @@ const de_PutBucketLoggingCommand = async (output, context) => {
5498
5427
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5499
5428
  return de_PutBucketLoggingCommandError(output, context);
5500
5429
  }
5501
- const contents = map({
5430
+ const contents = (0, smithy_client_1.map)({
5502
5431
  $metadata: deserializeMetadata(output),
5503
5432
  });
5504
5433
  await collectBody(output.body, context);
@@ -5512,10 +5441,9 @@ const de_PutBucketLoggingCommandError = async (output, context) => {
5512
5441
  };
5513
5442
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5514
5443
  const parsedBody = parsedOutput.body;
5515
- (0, smithy_client_1.throwDefaultError)({
5444
+ return throwDefaultError({
5516
5445
  output,
5517
5446
  parsedBody,
5518
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5519
5447
  errorCode,
5520
5448
  });
5521
5449
  };
@@ -5523,7 +5451,7 @@ const de_PutBucketMetricsConfigurationCommand = async (output, context) => {
5523
5451
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5524
5452
  return de_PutBucketMetricsConfigurationCommandError(output, context);
5525
5453
  }
5526
- const contents = map({
5454
+ const contents = (0, smithy_client_1.map)({
5527
5455
  $metadata: deserializeMetadata(output),
5528
5456
  });
5529
5457
  await collectBody(output.body, context);
@@ -5537,10 +5465,9 @@ const de_PutBucketMetricsConfigurationCommandError = async (output, context) =>
5537
5465
  };
5538
5466
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5539
5467
  const parsedBody = parsedOutput.body;
5540
- (0, smithy_client_1.throwDefaultError)({
5468
+ return throwDefaultError({
5541
5469
  output,
5542
5470
  parsedBody,
5543
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5544
5471
  errorCode,
5545
5472
  });
5546
5473
  };
@@ -5548,7 +5475,7 @@ const de_PutBucketNotificationConfigurationCommand = async (output, context) =>
5548
5475
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5549
5476
  return de_PutBucketNotificationConfigurationCommandError(output, context);
5550
5477
  }
5551
- const contents = map({
5478
+ const contents = (0, smithy_client_1.map)({
5552
5479
  $metadata: deserializeMetadata(output),
5553
5480
  });
5554
5481
  await collectBody(output.body, context);
@@ -5562,10 +5489,9 @@ const de_PutBucketNotificationConfigurationCommandError = async (output, context
5562
5489
  };
5563
5490
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5564
5491
  const parsedBody = parsedOutput.body;
5565
- (0, smithy_client_1.throwDefaultError)({
5492
+ return throwDefaultError({
5566
5493
  output,
5567
5494
  parsedBody,
5568
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5569
5495
  errorCode,
5570
5496
  });
5571
5497
  };
@@ -5573,7 +5499,7 @@ const de_PutBucketOwnershipControlsCommand = async (output, context) => {
5573
5499
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5574
5500
  return de_PutBucketOwnershipControlsCommandError(output, context);
5575
5501
  }
5576
- const contents = map({
5502
+ const contents = (0, smithy_client_1.map)({
5577
5503
  $metadata: deserializeMetadata(output),
5578
5504
  });
5579
5505
  await collectBody(output.body, context);
@@ -5587,10 +5513,9 @@ const de_PutBucketOwnershipControlsCommandError = async (output, context) => {
5587
5513
  };
5588
5514
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5589
5515
  const parsedBody = parsedOutput.body;
5590
- (0, smithy_client_1.throwDefaultError)({
5516
+ return throwDefaultError({
5591
5517
  output,
5592
5518
  parsedBody,
5593
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5594
5519
  errorCode,
5595
5520
  });
5596
5521
  };
@@ -5598,7 +5523,7 @@ const de_PutBucketPolicyCommand = async (output, context) => {
5598
5523
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5599
5524
  return de_PutBucketPolicyCommandError(output, context);
5600
5525
  }
5601
- const contents = map({
5526
+ const contents = (0, smithy_client_1.map)({
5602
5527
  $metadata: deserializeMetadata(output),
5603
5528
  });
5604
5529
  await collectBody(output.body, context);
@@ -5612,10 +5537,9 @@ const de_PutBucketPolicyCommandError = async (output, context) => {
5612
5537
  };
5613
5538
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5614
5539
  const parsedBody = parsedOutput.body;
5615
- (0, smithy_client_1.throwDefaultError)({
5540
+ return throwDefaultError({
5616
5541
  output,
5617
5542
  parsedBody,
5618
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5619
5543
  errorCode,
5620
5544
  });
5621
5545
  };
@@ -5623,7 +5547,7 @@ const de_PutBucketReplicationCommand = async (output, context) => {
5623
5547
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5624
5548
  return de_PutBucketReplicationCommandError(output, context);
5625
5549
  }
5626
- const contents = map({
5550
+ const contents = (0, smithy_client_1.map)({
5627
5551
  $metadata: deserializeMetadata(output),
5628
5552
  });
5629
5553
  await collectBody(output.body, context);
@@ -5637,10 +5561,9 @@ const de_PutBucketReplicationCommandError = async (output, context) => {
5637
5561
  };
5638
5562
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5639
5563
  const parsedBody = parsedOutput.body;
5640
- (0, smithy_client_1.throwDefaultError)({
5564
+ return throwDefaultError({
5641
5565
  output,
5642
5566
  parsedBody,
5643
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5644
5567
  errorCode,
5645
5568
  });
5646
5569
  };
@@ -5648,7 +5571,7 @@ const de_PutBucketRequestPaymentCommand = async (output, context) => {
5648
5571
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5649
5572
  return de_PutBucketRequestPaymentCommandError(output, context);
5650
5573
  }
5651
- const contents = map({
5574
+ const contents = (0, smithy_client_1.map)({
5652
5575
  $metadata: deserializeMetadata(output),
5653
5576
  });
5654
5577
  await collectBody(output.body, context);
@@ -5662,10 +5585,9 @@ const de_PutBucketRequestPaymentCommandError = async (output, context) => {
5662
5585
  };
5663
5586
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5664
5587
  const parsedBody = parsedOutput.body;
5665
- (0, smithy_client_1.throwDefaultError)({
5588
+ return throwDefaultError({
5666
5589
  output,
5667
5590
  parsedBody,
5668
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5669
5591
  errorCode,
5670
5592
  });
5671
5593
  };
@@ -5673,7 +5595,7 @@ const de_PutBucketTaggingCommand = async (output, context) => {
5673
5595
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5674
5596
  return de_PutBucketTaggingCommandError(output, context);
5675
5597
  }
5676
- const contents = map({
5598
+ const contents = (0, smithy_client_1.map)({
5677
5599
  $metadata: deserializeMetadata(output),
5678
5600
  });
5679
5601
  await collectBody(output.body, context);
@@ -5687,10 +5609,9 @@ const de_PutBucketTaggingCommandError = async (output, context) => {
5687
5609
  };
5688
5610
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5689
5611
  const parsedBody = parsedOutput.body;
5690
- (0, smithy_client_1.throwDefaultError)({
5612
+ return throwDefaultError({
5691
5613
  output,
5692
5614
  parsedBody,
5693
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5694
5615
  errorCode,
5695
5616
  });
5696
5617
  };
@@ -5698,7 +5619,7 @@ const de_PutBucketVersioningCommand = async (output, context) => {
5698
5619
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5699
5620
  return de_PutBucketVersioningCommandError(output, context);
5700
5621
  }
5701
- const contents = map({
5622
+ const contents = (0, smithy_client_1.map)({
5702
5623
  $metadata: deserializeMetadata(output),
5703
5624
  });
5704
5625
  await collectBody(output.body, context);
@@ -5712,10 +5633,9 @@ const de_PutBucketVersioningCommandError = async (output, context) => {
5712
5633
  };
5713
5634
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5714
5635
  const parsedBody = parsedOutput.body;
5715
- (0, smithy_client_1.throwDefaultError)({
5636
+ return throwDefaultError({
5716
5637
  output,
5717
5638
  parsedBody,
5718
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5719
5639
  errorCode,
5720
5640
  });
5721
5641
  };
@@ -5723,7 +5643,7 @@ const de_PutBucketWebsiteCommand = async (output, context) => {
5723
5643
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5724
5644
  return de_PutBucketWebsiteCommandError(output, context);
5725
5645
  }
5726
- const contents = map({
5646
+ const contents = (0, smithy_client_1.map)({
5727
5647
  $metadata: deserializeMetadata(output),
5728
5648
  });
5729
5649
  await collectBody(output.body, context);
@@ -5737,10 +5657,9 @@ const de_PutBucketWebsiteCommandError = async (output, context) => {
5737
5657
  };
5738
5658
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5739
5659
  const parsedBody = parsedOutput.body;
5740
- (0, smithy_client_1.throwDefaultError)({
5660
+ return throwDefaultError({
5741
5661
  output,
5742
5662
  parsedBody,
5743
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5744
5663
  errorCode,
5745
5664
  });
5746
5665
  };
@@ -5748,7 +5667,7 @@ const de_PutObjectCommand = async (output, context) => {
5748
5667
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5749
5668
  return de_PutObjectCommandError(output, context);
5750
5669
  }
5751
- const contents = map({
5670
+ const contents = (0, smithy_client_1.map)({
5752
5671
  $metadata: deserializeMetadata(output),
5753
5672
  Expiration: [, output.headers["x-amz-expiration"]],
5754
5673
  ETag: [, output.headers["etag"]],
@@ -5779,10 +5698,9 @@ const de_PutObjectCommandError = async (output, context) => {
5779
5698
  };
5780
5699
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5781
5700
  const parsedBody = parsedOutput.body;
5782
- (0, smithy_client_1.throwDefaultError)({
5701
+ return throwDefaultError({
5783
5702
  output,
5784
5703
  parsedBody,
5785
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5786
5704
  errorCode,
5787
5705
  });
5788
5706
  };
@@ -5790,7 +5708,7 @@ const de_PutObjectAclCommand = async (output, context) => {
5790
5708
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5791
5709
  return de_PutObjectAclCommandError(output, context);
5792
5710
  }
5793
- const contents = map({
5711
+ const contents = (0, smithy_client_1.map)({
5794
5712
  $metadata: deserializeMetadata(output),
5795
5713
  RequestCharged: [, output.headers["x-amz-request-charged"]],
5796
5714
  });
@@ -5810,10 +5728,9 @@ const de_PutObjectAclCommandError = async (output, context) => {
5810
5728
  throw await de_NoSuchKeyRes(parsedOutput, context);
5811
5729
  default:
5812
5730
  const parsedBody = parsedOutput.body;
5813
- (0, smithy_client_1.throwDefaultError)({
5731
+ return throwDefaultError({
5814
5732
  output,
5815
5733
  parsedBody,
5816
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5817
5734
  errorCode,
5818
5735
  });
5819
5736
  }
@@ -5822,7 +5739,7 @@ const de_PutObjectLegalHoldCommand = async (output, context) => {
5822
5739
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5823
5740
  return de_PutObjectLegalHoldCommandError(output, context);
5824
5741
  }
5825
- const contents = map({
5742
+ const contents = (0, smithy_client_1.map)({
5826
5743
  $metadata: deserializeMetadata(output),
5827
5744
  RequestCharged: [, output.headers["x-amz-request-charged"]],
5828
5745
  });
@@ -5837,10 +5754,9 @@ const de_PutObjectLegalHoldCommandError = async (output, context) => {
5837
5754
  };
5838
5755
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5839
5756
  const parsedBody = parsedOutput.body;
5840
- (0, smithy_client_1.throwDefaultError)({
5757
+ return throwDefaultError({
5841
5758
  output,
5842
5759
  parsedBody,
5843
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5844
5760
  errorCode,
5845
5761
  });
5846
5762
  };
@@ -5848,7 +5764,7 @@ const de_PutObjectLockConfigurationCommand = async (output, context) => {
5848
5764
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5849
5765
  return de_PutObjectLockConfigurationCommandError(output, context);
5850
5766
  }
5851
- const contents = map({
5767
+ const contents = (0, smithy_client_1.map)({
5852
5768
  $metadata: deserializeMetadata(output),
5853
5769
  RequestCharged: [, output.headers["x-amz-request-charged"]],
5854
5770
  });
@@ -5863,10 +5779,9 @@ const de_PutObjectLockConfigurationCommandError = async (output, context) => {
5863
5779
  };
5864
5780
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5865
5781
  const parsedBody = parsedOutput.body;
5866
- (0, smithy_client_1.throwDefaultError)({
5782
+ return throwDefaultError({
5867
5783
  output,
5868
5784
  parsedBody,
5869
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5870
5785
  errorCode,
5871
5786
  });
5872
5787
  };
@@ -5874,7 +5789,7 @@ const de_PutObjectRetentionCommand = async (output, context) => {
5874
5789
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5875
5790
  return de_PutObjectRetentionCommandError(output, context);
5876
5791
  }
5877
- const contents = map({
5792
+ const contents = (0, smithy_client_1.map)({
5878
5793
  $metadata: deserializeMetadata(output),
5879
5794
  RequestCharged: [, output.headers["x-amz-request-charged"]],
5880
5795
  });
@@ -5889,10 +5804,9 @@ const de_PutObjectRetentionCommandError = async (output, context) => {
5889
5804
  };
5890
5805
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5891
5806
  const parsedBody = parsedOutput.body;
5892
- (0, smithy_client_1.throwDefaultError)({
5807
+ return throwDefaultError({
5893
5808
  output,
5894
5809
  parsedBody,
5895
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5896
5810
  errorCode,
5897
5811
  });
5898
5812
  };
@@ -5900,7 +5814,7 @@ const de_PutObjectTaggingCommand = async (output, context) => {
5900
5814
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5901
5815
  return de_PutObjectTaggingCommandError(output, context);
5902
5816
  }
5903
- const contents = map({
5817
+ const contents = (0, smithy_client_1.map)({
5904
5818
  $metadata: deserializeMetadata(output),
5905
5819
  VersionId: [, output.headers["x-amz-version-id"]],
5906
5820
  });
@@ -5915,10 +5829,9 @@ const de_PutObjectTaggingCommandError = async (output, context) => {
5915
5829
  };
5916
5830
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5917
5831
  const parsedBody = parsedOutput.body;
5918
- (0, smithy_client_1.throwDefaultError)({
5832
+ return throwDefaultError({
5919
5833
  output,
5920
5834
  parsedBody,
5921
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5922
5835
  errorCode,
5923
5836
  });
5924
5837
  };
@@ -5926,7 +5839,7 @@ const de_PutPublicAccessBlockCommand = async (output, context) => {
5926
5839
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5927
5840
  return de_PutPublicAccessBlockCommandError(output, context);
5928
5841
  }
5929
- const contents = map({
5842
+ const contents = (0, smithy_client_1.map)({
5930
5843
  $metadata: deserializeMetadata(output),
5931
5844
  });
5932
5845
  await collectBody(output.body, context);
@@ -5940,10 +5853,9 @@ const de_PutPublicAccessBlockCommandError = async (output, context) => {
5940
5853
  };
5941
5854
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
5942
5855
  const parsedBody = parsedOutput.body;
5943
- (0, smithy_client_1.throwDefaultError)({
5856
+ return throwDefaultError({
5944
5857
  output,
5945
5858
  parsedBody,
5946
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5947
5859
  errorCode,
5948
5860
  });
5949
5861
  };
@@ -5951,7 +5863,7 @@ const de_RestoreObjectCommand = async (output, context) => {
5951
5863
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5952
5864
  return de_RestoreObjectCommandError(output, context);
5953
5865
  }
5954
- const contents = map({
5866
+ const contents = (0, smithy_client_1.map)({
5955
5867
  $metadata: deserializeMetadata(output),
5956
5868
  RequestCharged: [, output.headers["x-amz-request-charged"]],
5957
5869
  RestoreOutputPath: [, output.headers["x-amz-restore-output-path"]],
@@ -5972,10 +5884,9 @@ const de_RestoreObjectCommandError = async (output, context) => {
5972
5884
  throw await de_ObjectAlreadyInActiveTierErrorRes(parsedOutput, context);
5973
5885
  default:
5974
5886
  const parsedBody = parsedOutput.body;
5975
- (0, smithy_client_1.throwDefaultError)({
5887
+ return throwDefaultError({
5976
5888
  output,
5977
5889
  parsedBody,
5978
- exceptionCtor: S3ServiceException_1.S3ServiceException,
5979
5890
  errorCode,
5980
5891
  });
5981
5892
  }
@@ -5984,7 +5895,7 @@ const de_SelectObjectContentCommand = async (output, context) => {
5984
5895
  if (output.statusCode !== 200 && output.statusCode >= 300) {
5985
5896
  return de_SelectObjectContentCommandError(output, context);
5986
5897
  }
5987
- const contents = map({
5898
+ const contents = (0, smithy_client_1.map)({
5988
5899
  $metadata: deserializeMetadata(output),
5989
5900
  });
5990
5901
  const data = output.body;
@@ -5999,10 +5910,9 @@ const de_SelectObjectContentCommandError = async (output, context) => {
5999
5910
  };
6000
5911
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
6001
5912
  const parsedBody = parsedOutput.body;
6002
- (0, smithy_client_1.throwDefaultError)({
5913
+ return throwDefaultError({
6003
5914
  output,
6004
5915
  parsedBody,
6005
- exceptionCtor: S3ServiceException_1.S3ServiceException,
6006
5916
  errorCode,
6007
5917
  });
6008
5918
  };
@@ -6010,7 +5920,7 @@ const de_UploadPartCommand = async (output, context) => {
6010
5920
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6011
5921
  return de_UploadPartCommandError(output, context);
6012
5922
  }
6013
- const contents = map({
5923
+ const contents = (0, smithy_client_1.map)({
6014
5924
  $metadata: deserializeMetadata(output),
6015
5925
  ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]],
6016
5926
  ETag: [, output.headers["etag"]],
@@ -6038,10 +5948,9 @@ const de_UploadPartCommandError = async (output, context) => {
6038
5948
  };
6039
5949
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
6040
5950
  const parsedBody = parsedOutput.body;
6041
- (0, smithy_client_1.throwDefaultError)({
5951
+ return throwDefaultError({
6042
5952
  output,
6043
5953
  parsedBody,
6044
- exceptionCtor: S3ServiceException_1.S3ServiceException,
6045
5954
  errorCode,
6046
5955
  });
6047
5956
  };
@@ -6049,7 +5958,7 @@ const de_UploadPartCopyCommand = async (output, context) => {
6049
5958
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6050
5959
  return de_UploadPartCopyCommandError(output, context);
6051
5960
  }
6052
- const contents = map({
5961
+ const contents = (0, smithy_client_1.map)({
6053
5962
  $metadata: deserializeMetadata(output),
6054
5963
  CopySourceVersionId: [, output.headers["x-amz-copy-source-version-id"]],
6055
5964
  ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]],
@@ -6074,10 +5983,9 @@ const de_UploadPartCopyCommandError = async (output, context) => {
6074
5983
  };
6075
5984
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
6076
5985
  const parsedBody = parsedOutput.body;
6077
- (0, smithy_client_1.throwDefaultError)({
5986
+ return throwDefaultError({
6078
5987
  output,
6079
5988
  parsedBody,
6080
- exceptionCtor: S3ServiceException_1.S3ServiceException,
6081
5989
  errorCode,
6082
5990
  });
6083
5991
  };
@@ -6085,7 +5993,7 @@ const de_WriteGetObjectResponseCommand = async (output, context) => {
6085
5993
  if (output.statusCode !== 200 && output.statusCode >= 300) {
6086
5994
  return de_WriteGetObjectResponseCommandError(output, context);
6087
5995
  }
6088
- const contents = map({
5996
+ const contents = (0, smithy_client_1.map)({
6089
5997
  $metadata: deserializeMetadata(output),
6090
5998
  });
6091
5999
  await collectBody(output.body, context);
@@ -6099,16 +6007,15 @@ const de_WriteGetObjectResponseCommandError = async (output, context) => {
6099
6007
  };
6100
6008
  const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
6101
6009
  const parsedBody = parsedOutput.body;
6102
- (0, smithy_client_1.throwDefaultError)({
6010
+ return throwDefaultError({
6103
6011
  output,
6104
6012
  parsedBody,
6105
- exceptionCtor: S3ServiceException_1.S3ServiceException,
6106
6013
  errorCode,
6107
6014
  });
6108
6015
  };
6109
- const map = smithy_client_1.map;
6016
+ const throwDefaultError = (0, smithy_client_1.withBaseException)(S3ServiceException_1.S3ServiceException);
6110
6017
  const de_BucketAlreadyExistsRes = async (parsedOutput, context) => {
6111
- const contents = map({});
6018
+ const contents = (0, smithy_client_1.map)({});
6112
6019
  const data = parsedOutput.body;
6113
6020
  const exception = new models_0_1.BucketAlreadyExists({
6114
6021
  $metadata: deserializeMetadata(parsedOutput),
@@ -6117,7 +6024,7 @@ const de_BucketAlreadyExistsRes = async (parsedOutput, context) => {
6117
6024
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
6118
6025
  };
6119
6026
  const de_BucketAlreadyOwnedByYouRes = async (parsedOutput, context) => {
6120
- const contents = map({});
6027
+ const contents = (0, smithy_client_1.map)({});
6121
6028
  const data = parsedOutput.body;
6122
6029
  const exception = new models_0_1.BucketAlreadyOwnedByYou({
6123
6030
  $metadata: deserializeMetadata(parsedOutput),
@@ -6126,7 +6033,7 @@ const de_BucketAlreadyOwnedByYouRes = async (parsedOutput, context) => {
6126
6033
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
6127
6034
  };
6128
6035
  const de_InvalidObjectStateRes = async (parsedOutput, context) => {
6129
- const contents = map({});
6036
+ const contents = (0, smithy_client_1.map)({});
6130
6037
  const data = parsedOutput.body;
6131
6038
  if (data["AccessTier"] !== undefined) {
6132
6039
  contents.AccessTier = (0, smithy_client_1.expectString)(data["AccessTier"]);
@@ -6141,7 +6048,7 @@ const de_InvalidObjectStateRes = async (parsedOutput, context) => {
6141
6048
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
6142
6049
  };
6143
6050
  const de_NoSuchBucketRes = async (parsedOutput, context) => {
6144
- const contents = map({});
6051
+ const contents = (0, smithy_client_1.map)({});
6145
6052
  const data = parsedOutput.body;
6146
6053
  const exception = new models_0_1.NoSuchBucket({
6147
6054
  $metadata: deserializeMetadata(parsedOutput),
@@ -6150,7 +6057,7 @@ const de_NoSuchBucketRes = async (parsedOutput, context) => {
6150
6057
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
6151
6058
  };
6152
6059
  const de_NoSuchKeyRes = async (parsedOutput, context) => {
6153
- const contents = map({});
6060
+ const contents = (0, smithy_client_1.map)({});
6154
6061
  const data = parsedOutput.body;
6155
6062
  const exception = new models_0_1.NoSuchKey({
6156
6063
  $metadata: deserializeMetadata(parsedOutput),
@@ -6159,7 +6066,7 @@ const de_NoSuchKeyRes = async (parsedOutput, context) => {
6159
6066
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
6160
6067
  };
6161
6068
  const de_NoSuchUploadRes = async (parsedOutput, context) => {
6162
- const contents = map({});
6069
+ const contents = (0, smithy_client_1.map)({});
6163
6070
  const data = parsedOutput.body;
6164
6071
  const exception = new models_0_1.NoSuchUpload({
6165
6072
  $metadata: deserializeMetadata(parsedOutput),
@@ -6168,7 +6075,7 @@ const de_NoSuchUploadRes = async (parsedOutput, context) => {
6168
6075
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
6169
6076
  };
6170
6077
  const de_NotFoundRes = async (parsedOutput, context) => {
6171
- const contents = map({});
6078
+ const contents = (0, smithy_client_1.map)({});
6172
6079
  const data = parsedOutput.body;
6173
6080
  const exception = new models_0_1.NotFound({
6174
6081
  $metadata: deserializeMetadata(parsedOutput),
@@ -6177,7 +6084,7 @@ const de_NotFoundRes = async (parsedOutput, context) => {
6177
6084
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
6178
6085
  };
6179
6086
  const de_ObjectAlreadyInActiveTierErrorRes = async (parsedOutput, context) => {
6180
- const contents = map({});
6087
+ const contents = (0, smithy_client_1.map)({});
6181
6088
  const data = parsedOutput.body;
6182
6089
  const exception = new models_1_1.ObjectAlreadyInActiveTierError({
6183
6090
  $metadata: deserializeMetadata(parsedOutput),
@@ -6186,7 +6093,7 @@ const de_ObjectAlreadyInActiveTierErrorRes = async (parsedOutput, context) => {
6186
6093
  return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
6187
6094
  };
6188
6095
  const de_ObjectNotInActiveTierErrorRes = async (parsedOutput, context) => {
6189
- const contents = map({});
6096
+ const contents = (0, smithy_client_1.map)({});
6190
6097
  const data = parsedOutput.body;
6191
6098
  const exception = new models_0_1.ObjectNotInActiveTierError({
6192
6099
  $metadata: deserializeMetadata(parsedOutput),