serverless-spy 2.2.6 → 2.2.7

package/node_modules/@aws-sdk/client-s3/dist-es/protocols/Aws_restXml.js

@@ -1,16 +1,17 @@
+import { loadRestXmlErrorCode, parseXmlBody as parseBody, parseXmlErrorBody as parseErrorBody } from "@aws-sdk/core";
 import { XmlNode as __XmlNode, XmlText as __XmlText } from "@aws-sdk/xml-builder";
 import { requestBuilder as rb } from "@smithy/core";
 import { isValidHostname as __isValidHostname, } from "@smithy/protocol-http";
-import { collectBody, dateToUtcString as __dateToUtcString, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, expectUnion as __expectUnion, getArrayIfSingleItem as __getArrayIfSingleItem, getValueFromTextNode as __getValueFromTextNode, map, parseBoolean as __parseBoolean, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, parseRfc7231DateTime as __parseRfc7231DateTime, strictParseInt32 as __strictParseInt32, strictParseLong as __strictParseLong, withBaseException, } from "@smithy/smithy-client";
-import { XMLParser } from "fast-xml-parser";
-import { AnalyticsFilter, BucketAlreadyExists, BucketAlreadyOwnedByYou, InvalidObjectState, LifecycleRuleFilter, MetricsFilter, NoSuchBucket, NoSuchKey, NoSuchUpload, NotFound, ObjectNotInActiveTierError, ReplicationRuleFilter, } from "../models/models_0";
-import { ObjectAlreadyInActiveTierError, } from "../models/models_1";
+import { collectBody, dateToUtcString as __dateToUtcString, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, expectUnion as __expectUnion, getArrayIfSingleItem as __getArrayIfSingleItem, isSerializableHeaderValue, map, parseBoolean as __parseBoolean, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, parseRfc7231DateTime as __parseRfc7231DateTime, quoteHeader as __quoteHeader, serializeDateTime as __serializeDateTime, strictParseInt32 as __strictParseInt32, strictParseLong as __strictParseLong, withBaseException, } from "@smithy/smithy-client";
+import { AnalyticsFilter, BucketAlreadyExists, BucketAlreadyOwnedByYou, InvalidObjectState, MetricsFilter, NoSuchBucket, NoSuchKey, NoSuchUpload, NotFound, ObjectNotInActiveTierError, } from "../models/models_0";
+import { EncryptionTypeMismatch, InvalidRequest, InvalidWriteOffset, ObjectAlreadyInActiveTierError, TooManyParts, } from "../models/models_1";
 import { S3ServiceException as __BaseException } from "../models/S3ServiceException";
 export const se_AbortMultipartUploadCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         [_xarp]: input[_RP],
         [_xaebo]: input[_EBO],
+        [_xaimit]: [() => isSerializableHeaderValue(input[_IMIT]), () => __dateToUtcString(input[_IMIT]).toString()],
     });
     b.bp("/{Key+}");
     b.p("Bucket", () => input.Bucket, "{Bucket}", false);
@@ -33,6 +34,8 @@ export const se_CompleteMultipartUploadCommand = async (input, context) => {
         [_xacs_]: input[_CSHAh],
         [_xarp]: input[_RP],
         [_xaebo]: input[_EBO],
+        [_im]: input[_IM],
+        [_inm]: input[_INM],
         [_xasseca]: input[_SSECA],
         [_xasseck]: input[_SSECK],
         [_xasseckm]: input[_SSECKMD],
@@ -41,7 +44,6 @@ export const se_CompleteMultipartUploadCommand = async (input, context) => {
     b.p("Bucket", () => input.Bucket, "{Bucket}", false);
     b.p("Key", () => input.Key, "{Key+}", true);
     const query = map({
-        [_xi]: [, "CompleteMultipartUpload"],
         [_uI]: [, __expectNonNull(input[_UI], `UploadId`)],
     });
     let body;
@@ -93,10 +95,7 @@ export const se_CopyObjectCommand = async (input, context) => {
         [_xarp]: input[_RP],
         [_xat]: input[_T],
         [_xaolm]: input[_OLM],
-        [_xaolrud]: [
-            () => isSerializableHeaderValue(input[_OLRUD]),
-            () => (input[_OLRUD].toISOString().split(".")[0] + "Z").toString(),
-        ],
+        [_xaolrud]: [() => isSerializableHeaderValue(input[_OLRUD]), () => __serializeDateTime(input[_OLRUD]).toString()],
         [_xaollh]: input[_OLLHS],
         [_xaebo]: input[_EBO],
         [_xasebo]: input[_ESBO],
@@ -142,6 +141,30 @@ export const se_CreateBucketCommand = async (input, context) => {
     b.m("PUT").h(headers).b(body);
     return b.build();
 };
+export const se_CreateBucketMetadataTableConfigurationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/xml",
+        [_cm]: input[_CMD],
+        [_xasca]: input[_CA],
+        [_xaebo]: input[_EBO],
+    });
+    b.bp("/");
+    b.p("Bucket", () => input.Bucket, "{Bucket}", false);
+    const query = map({
+        [_mT]: [, ""],
+    });
+    let body;
+    let contents;
+    if (input.MetadataTableConfiguration !== undefined) {
+        contents = se_MetadataTableConfiguration(input.MetadataTableConfiguration, context);
+        body = _ve;
+        contents.a("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/");
+        body += contents.toString();
+    }
+    b.m("POST").h(headers).q(query).b(body);
+    return b.build();
+};
 export const se_CreateMultipartUploadCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
@@ -168,10 +191,7 @@ export const se_CreateMultipartUploadCommand = async (input, context) => {
         [_xarp]: input[_RP],
         [_xat]: input[_T],
         [_xaolm]: input[_OLM],
-        [_xaolrud]: [
-            () => isSerializableHeaderValue(input[_OLRUD]),
-            () => (input[_OLRUD].toISOString().split(".")[0] + "Z").toString(),
-        ],
+        [_xaolrud]: [() => isSerializableHeaderValue(input[_OLRUD]), () => __serializeDateTime(input[_OLRUD]).toString()],
         [_xaollh]: input[_OLLHS],
         [_xaebo]: input[_EBO],
         [_xaca]: input[_CA],
@@ -186,7 +206,6 @@ export const se_CreateMultipartUploadCommand = async (input, context) => {
     b.p("Key", () => input.Key, "{Key+}", true);
     const query = map({
         [_u]: [, ""],
-        [_xi]: [, "CreateMultipartUpload"],
     });
     let body;
     b.m("POST").h(headers).q(query).b(body);
@@ -196,6 +215,10 @@ export const se_CreateSessionCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         [_xacsm]: input[_SM],
+        [_xasse]: input[_SSE],
+        [_xasseakki]: input[_SSEKMSKI],
+        [_xassec]: input[_SSEKMSEC],
+        [_xassebke]: [() => isSerializableHeaderValue(input[_BKE]), () => input[_BKE].toString()],
     });
     b.bp("/");
     b.p("Bucket", () => input.Bucket, "{Bucket}", false);
@@ -302,6 +325,20 @@ export const se_DeleteBucketLifecycleCommand = async (input, context) => {
     b.m("DELETE").h(headers).q(query).b(body);
     return b.build();
 };
+export const se_DeleteBucketMetadataTableConfigurationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        [_xaebo]: input[_EBO],
+    });
+    b.bp("/");
+    b.p("Bucket", () => input.Bucket, "{Bucket}", false);
+    const query = map({
+        [_mT]: [, ""],
+    });
+    let body;
+    b.m("DELETE").h(headers).q(query).b(body);
+    return b.build();
+};
 export const se_DeleteBucketMetricsConfigurationCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
@@ -394,6 +431,9 @@ export const se_DeleteObjectCommand = async (input, context) => {
         [_xarp]: input[_RP],
         [_xabgr]: [() => isSerializableHeaderValue(input[_BGR]), () => input[_BGR].toString()],
         [_xaebo]: input[_EBO],
+        [_im]: input[_IM],
+        [_xaimlmt]: [() => isSerializableHeaderValue(input[_IMLMT]), () => __dateToUtcString(input[_IMLMT]).toString()],
+        [_xaims]: [() => isSerializableHeaderValue(input[_IMS]), () => input[_IMS].toString()],
     });
     b.bp("/{Key+}");
     b.p("Bucket", () => input.Bucket, "{Bucket}", false);
@@ -420,7 +460,6 @@ export const se_DeleteObjectsCommand = async (input, context) => {
     b.p("Bucket", () => input.Bucket, "{Bucket}", false);
     const query = map({
         [_d]: [, ""],
-        [_xi]: [, "DeleteObjects"],
     });
     let body;
     let contents;
@@ -608,6 +647,20 @@ export const se_GetBucketLoggingCommand = async (input, context) => {
     b.m("GET").h(headers).q(query).b(body);
     return b.build();
 };
+export const se_GetBucketMetadataTableConfigurationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        [_xaebo]: input[_EBO],
+    });
+    b.bp("/");
+    b.p("Bucket", () => input.Bucket, "{Bucket}", false);
+    const query = map({
+        [_mT]: [, ""],
+    });
+    let body;
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
+};
 export const se_GetBucketMetricsConfigurationCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
@@ -754,7 +807,7 @@ export const se_GetObjectCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         [_im]: input[_IM],
-        [_ims]: [() => isSerializableHeaderValue(input[_IMS]), () => __dateToUtcString(input[_IMS]).toString()],
+        [_ims]: [() => isSerializableHeaderValue(input[_IMSf]), () => __dateToUtcString(input[_IMSf]).toString()],
         [_inm]: input[_INM],
         [_ius]: [() => isSerializableHeaderValue(input[_IUS]), () => __dateToUtcString(input[_IUS]).toString()],
         [_ra]: input[_R],
@@ -810,10 +863,7 @@ export const se_GetObjectAttributesCommand = async (input, context) => {
         [_xasseckm]: input[_SSECKMD],
         [_xarp]: input[_RP],
         [_xaebo]: input[_EBO],
-        [_xaoa]: [
-            () => isSerializableHeaderValue(input[_OA]),
-            () => (input[_OA] || []).map((_entry) => _entry).join(", "),
-        ],
+        [_xaoa]: [() => isSerializableHeaderValue(input[_OA]), () => (input[_OA] || []).map(__quoteHeader).join(", ")],
     });
     b.bp("/{Key+}");
     b.p("Bucket", () => input.Bucket, "{Bucket}", false);
@@ -936,7 +986,7 @@ export const se_HeadObjectCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
         [_im]: input[_IM],
-        [_ims]: [() => isSerializableHeaderValue(input[_IMS]), () => __dateToUtcString(input[_IMS]).toString()],
+        [_ims]: [() => isSerializableHeaderValue(input[_IMSf]), () => __dateToUtcString(input[_IMSf]).toString()],
         [_inm]: input[_INM],
         [_ius]: [() => isSerializableHeaderValue(input[_IUS]), () => __dateToUtcString(input[_IUS]).toString()],
         [_ra]: input[_R],
@@ -951,6 +1001,12 @@ export const se_HeadObjectCommand = async (input, context) => {
     b.p("Bucket", () => input.Bucket, "{Bucket}", false);
     b.p("Key", () => input.Key, "{Key+}", true);
     const query = map({
+        [_rcc]: [, input[_RCC]],
+        [_rcd]: [, input[_RCD]],
+        [_rce]: [, input[_RCE]],
+        [_rcl]: [, input[_RCL]],
+        [_rct]: [, input[_RCT]],
+        [_re]: [() => input.ResponseExpires !== void 0, () => __dateToUtcString(input[_RE]).toString()],
         [_vI]: [, input[_VI]],
         [_pN]: [() => input.PartNumber !== void 0, () => input[_PN].toString()],
     });
@@ -1022,15 +1078,16 @@ export const se_ListBucketMetricsConfigurationsCommand = async (input, context)
 };
 export const se_ListBucketsCommand = async (input, context) => {
     const b = rb(input, context);
-    const headers = {
-        "content-type": "application/xml",
-    };
+    const headers = {};
     b.bp("/");
     const query = map({
         [_xi]: [, "ListBuckets"],
+        [_mb]: [() => input.MaxBuckets !== void 0, () => input[_MB].toString()],
+        [_ct_]: [, input[_CTo]],
+        [_pr]: [, input[_P]],
+        [_br]: [, input[_BR]],
     });
     let body;
-    body = "";
     b.m("GET").h(headers).q(query).b(body);
     return b.build();
 };
@@ -1073,10 +1130,7 @@ export const se_ListObjectsCommand = async (input, context) => {
     const headers = map({}, isSerializableHeaderValue, {
         [_xarp]: input[_RP],
         [_xaebo]: input[_EBO],
-        [_xaooa]: [
-            () => isSerializableHeaderValue(input[_OOA]),
-            () => (input[_OOA] || []).map((_entry) => _entry).join(", "),
-        ],
+        [_xaooa]: [() => isSerializableHeaderValue(input[_OOA]), () => (input[_OOA] || []).map(__quoteHeader).join(", ")],
     });
     b.bp("/");
     b.p("Bucket", () => input.Bucket, "{Bucket}", false);
@@ -1096,10 +1150,7 @@ export const se_ListObjectsV2Command = async (input, context) => {
     const headers = map({}, isSerializableHeaderValue, {
         [_xarp]: input[_RP],
         [_xaebo]: input[_EBO],
-        [_xaooa]: [
-            () => isSerializableHeaderValue(input[_OOA]),
-            () => (input[_OOA] || []).map((_entry) => _entry).join(", "),
-        ],
+        [_xaooa]: [() => isSerializableHeaderValue(input[_OOA]), () => (input[_OOA] || []).map(__quoteHeader).join(", ")],
     });
     b.bp("/");
     b.p("Bucket", () => input.Bucket, "{Bucket}", false);
@@ -1122,10 +1173,7 @@ export const se_ListObjectVersionsCommand = async (input, context) => {
     const headers = map({}, isSerializableHeaderValue, {
         [_xaebo]: input[_EBO],
         [_xarp]: input[_RP],
-        [_xaooa]: [
-            () => isSerializableHeaderValue(input[_OOA]),
-            () => (input[_OOA] || []).map((_entry) => _entry).join(", "),
-        ],
+        [_xaooa]: [() => isSerializableHeaderValue(input[_OOA]), () => (input[_OOA] || []).map(__quoteHeader).join(", ")],
     });
     b.bp("/");
     b.p("Bucket", () => input.Bucket, "{Bucket}", false);
@@ -1339,6 +1387,7 @@ export const se_PutBucketLifecycleConfigurationCommand = async (input, context)
         "content-type": "application/xml",
         [_xasca]: input[_CA],
         [_xaebo]: input[_EBO],
+        [_xatdmos]: input[_TDMOS],
     });
     b.bp("/");
     b.p("Bucket", () => input.Bucket, "{Bucket}", false);
@@ -1612,10 +1661,13 @@ export const se_PutObjectCommand = async (input, context) => {
         [_xacs]: input[_CSHA],
         [_xacs_]: input[_CSHAh],
         [_e]: [() => isSerializableHeaderValue(input[_E]), () => __dateToUtcString(input[_E]).toString()],
+        [_im]: input[_IM],
+        [_inm]: input[_INM],
         [_xagfc]: input[_GFC],
         [_xagr]: input[_GR],
         [_xagra]: input[_GRACP],
         [_xagwa]: input[_GWACP],
+        [_xawob]: [() => isSerializableHeaderValue(input[_WOB]), () => input[_WOB].toString()],
         [_xasse]: input[_SSE],
         [_xasc]: input[_SC],
         [_xawrl]: input[_WRL],
@@ -1628,10 +1680,7 @@ export const se_PutObjectCommand = async (input, context) => {
         [_xarp]: input[_RP],
         [_xat]: input[_T],
         [_xaolm]: input[_OLM],
-        [_xaolrud]: [
-            () => isSerializableHeaderValue(input[_OLRUD]),
-            () => (input[_OLRUD].toISOString().split(".")[0] + "Z").toString(),
-        ],
+        [_xaolrud]: [() => isSerializableHeaderValue(input[_OLRUD]), () => __serializeDateTime(input[_OLRUD]).toString()],
         [_xaollh]: input[_OLLHS],
         [_xaebo]: input[_EBO],
         ...(input.Metadata !== undefined &&
@@ -1835,7 +1884,6 @@ export const se_RestoreObjectCommand = async (input, context) => {
     b.p("Key", () => input.Key, "{Key+}", true);
     const query = map({
         [_res]: [, ""],
-        [_xi]: [, "RestoreObject"],
         [_vI]: [, input[_VI]],
     });
     let body;
@@ -1864,7 +1912,6 @@ export const se_SelectObjectContentCommand = async (input, context) => {
     const query = map({
         [_se]: [, ""],
         [_st]: [, "2"],
-        [_xi]: [, "SelectObjectContent"],
     });
     let body;
     body = _ve;
@@ -1985,7 +2032,7 @@ export const se_WriteGetObjectResponseCommand = async (input, context) => {
         [_xafhxaollh]: input[_OLLHS],
         [_xafhxaolrud]: [
             () => isSerializableHeaderValue(input[_OLRUD]),
-            () => (input[_OLRUD].toISOString().split(".")[0] + "Z").toString(),
+            () => __serializeDateTime(input[_OLRUD]).toString(),
         ],
         [_xafhxampc]: [() => isSerializableHeaderValue(input[_PC]), () => input[_PC].toString()],
         [_xafhxars]: input[_RS],
@@ -2006,9 +2053,6 @@ export const se_WriteGetObjectResponseCommand = async (input, context) => {
             }, {})),
     });
     b.bp("/WriteGetObjectResponse");
-    const query = map({
-        [_xi]: [, "WriteGetObjectResponse"],
-    });
     let body;
     let contents;
     if (input.Body !== undefined) {
@@ -2027,7 +2071,7 @@ export const se_WriteGetObjectResponseCommand = async (input, context) => {
         }
     }
     b.hn(resolvedHostname);
-    b.m("POST").h(headers).q(query).b(body);
+    b.m("POST").h(headers).b(body);
     return b.build();
 };
 export const de_AbortMultipartUploadCommand = async (output, context) => {
@@ -2113,6 +2157,16 @@ export const de_CreateBucketCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
+export const de_CreateBucketMetadataTableConfigurationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
 export const de_CreateMultipartUploadCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -2151,6 +2205,10 @@ export const de_CreateSessionCommand = async (output, context) => {
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
+        [_SSE]: [, output.headers[_xasse]],
+        [_SSEKMSKI]: [, output.headers[_xasseakki]],
+        [_SSEKMSEC]: [, output.headers[_xassec]],
+        [_BKE]: [() => void 0 !== output.headers[_xassebke], () => __parseBoolean(output.headers[_xassebke])],
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data[_C] != null) {
@@ -2228,6 +2286,16 @@ export const de_DeleteBucketLifecycleCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
+export const de_DeleteBucketMetadataTableConfigurationCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
 export const de_DeleteBucketMetricsConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -2444,6 +2512,7 @@ export const de_GetBucketLifecycleConfigurationCommand = async (output, context)
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
+        [_TDMOS]: [, output.headers[_xatdmos]],
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.Rule === "") {
@@ -2480,6 +2549,17 @@ export const de_GetBucketLoggingCommand = async (output, context) => {
     }
     return contents;
 };
+export const de_GetBucketMetadataTableConfigurationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectObject(await parseBody(output.body, context));
+    contents.GetBucketMetadataTableConfigurationResult = de_GetBucketMetadataTableConfigurationResult(data, context);
+    return contents;
+};
 export const de_GetBucketMetricsConfigurationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -3002,9 +3082,15 @@ export const de_ListBucketsCommand = async (output, context) => {
     else if (data[_Bu] != null && data[_Bu][_B] != null) {
         contents[_Bu] = de_Buckets(__getArrayIfSingleItem(data[_Bu][_B]), context);
     }
+    if (data[_CTo] != null) {
+        contents[_CTo] = __expectString(data[_CTo]);
+    }
     if (data[_O] != null) {
         contents[_O] = de_Owner(data[_O], context);
     }
+    if (data[_P] != null) {
+        contents[_P] = __expectString(data[_P]);
+    }
     return contents;
 };
 export const de_ListDirectoryBucketsCommand = async (output, context) => {
@@ -3369,6 +3455,7 @@ export const de_PutBucketLifecycleConfigurationCommand = async (output, context)
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
+        [_TDMOS]: [, output.headers[_xatdmos]],
     });
     await collectBody(output.body, context);
     return contents;
@@ -3492,6 +3579,7 @@ export const de_PutObjectCommand = async (output, context) => {
         [_SSEKMSKI]: [, output.headers[_xasseakki]],
         [_SSEKMSEC]: [, output.headers[_xassec]],
         [_BKE]: [() => void 0 !== output.headers[_xassebke], () => __parseBoolean(output.headers[_xassebke])],
+        [_Si]: [() => void 0 !== output.headers[_xaos], () => __strictParseLong(output.headers[_xaos])],
         [_RC]: [, output.headers[_xarc]],
     });
     await collectBody(output.body, context);
@@ -3665,6 +3753,18 @@ const de_CommandError = async (output, context) => {
         case "NotFound":
         case "com.amazonaws.s3#NotFound":
             throw await de_NotFoundRes(parsedOutput, context);
+        case "EncryptionTypeMismatch":
+        case "com.amazonaws.s3#EncryptionTypeMismatch":
+            throw await de_EncryptionTypeMismatchRes(parsedOutput, context);
+        case "InvalidRequest":
+        case "com.amazonaws.s3#InvalidRequest":
+            throw await de_InvalidRequestRes(parsedOutput, context);
+        case "InvalidWriteOffset":
+        case "com.amazonaws.s3#InvalidWriteOffset":
+            throw await de_InvalidWriteOffsetRes(parsedOutput, context);
+        case "TooManyParts":
+        case "com.amazonaws.s3#TooManyParts":
+            throw await de_TooManyPartsRes(parsedOutput, context);
         case "ObjectAlreadyInActiveTierError":
         case "com.amazonaws.s3#ObjectAlreadyInActiveTierError":
             throw await de_ObjectAlreadyInActiveTierErrorRes(parsedOutput, context);
@@ -3696,6 +3796,15 @@ const de_BucketAlreadyOwnedByYouRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_EncryptionTypeMismatchRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const exception = new EncryptionTypeMismatch({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_InvalidObjectStateRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -3711,6 +3820,24 @@ const de_InvalidObjectStateRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_InvalidRequestRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const exception = new InvalidRequest({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_InvalidWriteOffsetRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const exception = new InvalidWriteOffset({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_NoSuchBucketRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -3765,6 +3892,15 @@ const de_ObjectNotInActiveTierErrorRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_TooManyPartsRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const exception = new TooManyParts({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_SelectObjectContentEventStream = (output, context) => {
     return context.eventStreamMarshaller.deserialize(output, async (event) => {
         if (event["Records"] != null) {
@@ -4368,7 +4504,7 @@ const se_LambdaFunctionConfigurationList = (input, context) => {
 const se_LifecycleExpiration = (input, context) => {
     const bn = new __XmlNode(_LEi);
     if (input[_Dat] != null) {
-        bn.c(__XmlNode.of(_Dat, (input[_Dat].toISOString().split(".")[0] + "Z").toString()).n(_Dat));
+        bn.c(__XmlNode.of(_Dat, __serializeDateTime(input[_Dat]).toString()).n(_Dat));
     }
     if (input[_Da] != null) {
         bn.c(__XmlNode.of(_Da, String(input[_Da])).n(_Da));
@@ -4415,39 +4551,19 @@ const se_LifecycleRuleAndOperator = (input, context) => {
 };
 const se_LifecycleRuleFilter = (input, context) => {
     const bn = new __XmlNode(_LRF);
-    LifecycleRuleFilter.visit(input, {
-        Prefix: (value) => {
-            if (input[_P] != null) {
-                bn.c(__XmlNode.of(_P, value).n(_P));
-            }
-        },
-        Tag: (value) => {
-            if (input[_Ta] != null) {
-                bn.c(se_Tag(value, context).n(_Ta));
-            }
-        },
-        ObjectSizeGreaterThan: (value) => {
-            if (input[_OSGT] != null) {
-                bn.c(__XmlNode.of(_OSGTB, String(value)).n(_OSGT));
-            }
-        },
-        ObjectSizeLessThan: (value) => {
-            if (input[_OSLT] != null) {
-                bn.c(__XmlNode.of(_OSLTB, String(value)).n(_OSLT));
-            }
-        },
-        And: (value) => {
-            if (input[_A] != null) {
-                bn.c(se_LifecycleRuleAndOperator(value, context).n(_A));
-            }
-        },
-        _: (name, value) => {
-            if (!(value instanceof __XmlNode || value instanceof __XmlText)) {
-                throw new Error("Unable to serialize unknown union members in XML.");
-            }
-            bn.c(new __XmlNode(name).c(value));
-        },
-    });
+    bn.cc(input, _P);
+    if (input[_Ta] != null) {
+        bn.c(se_Tag(input[_Ta], context).n(_Ta));
+    }
+    if (input[_OSGT] != null) {
+        bn.c(__XmlNode.of(_OSGTB, String(input[_OSGT])).n(_OSGT));
+    }
+    if (input[_OSLT] != null) {
+        bn.c(__XmlNode.of(_OSLTB, String(input[_OSLT])).n(_OSLT));
+    }
+    if (input[_A] != null) {
+        bn.c(se_LifecycleRuleAndOperator(input[_A], context).n(_A));
+    }
     return bn;
 };
 const se_LifecycleRules = (input, context) => {
@@ -4488,6 +4604,13 @@ const se_MetadataEntry = (input, context) => {
     }
     return bn;
 };
+const se_MetadataTableConfiguration = (input, context) => {
+    const bn = new __XmlNode(_MTC);
+    if (input[_STD] != null) {
+        bn.c(se_S3TablesDestination(input[_STD], context).n(_STD));
+    }
+    return bn;
+};
 const se_Metrics = (input, context) => {
     const bn = new __XmlNode(_Me);
     if (input[_S] != null) {
@@ -4603,6 +4726,13 @@ const se_ObjectIdentifier = (input, context) => {
     if (input[_VI] != null) {
         bn.c(__XmlNode.of(_OVI, input[_VI]).n(_VI));
     }
+    bn.cc(input, _ETa);
+    if (input[_LMT] != null) {
+        bn.c(__XmlNode.of(_LMT, __dateToUtcString(input[_LMT]).toString()).n(_LMT));
+    }
+    if (input[_Si] != null) {
+        bn.c(__XmlNode.of(_Si, String(input[_Si])).n(_Si));
+    }
     return bn;
 };
 const se_ObjectIdentifierList = (input, context) => {
@@ -4634,7 +4764,7 @@ const se_ObjectLockRetention = (input, context) => {
         bn.c(__XmlNode.of(_OLRM, input[_Mo]).n(_Mo));
     }
     if (input[_RUD] != null) {
-        bn.c(__XmlNode.of(_Dat, (input[_RUD].toISOString().split(".")[0] + "Z").toString()).n(_RUD));
+        bn.c(__XmlNode.of(_Dat, __serializeDateTime(input[_RUD]).toString()).n(_RUD));
     }
     return bn;
 };
@@ -4796,29 +4926,13 @@ const se_ReplicationRuleAndOperator = (input, context) => {
 };
 const se_ReplicationRuleFilter = (input, context) => {
     const bn = new __XmlNode(_RRF);
-    ReplicationRuleFilter.visit(input, {
-        Prefix: (value) => {
-            if (input[_P] != null) {
-                bn.c(__XmlNode.of(_P, value).n(_P));
-            }
-        },
-        Tag: (value) => {
-            if (input[_Ta] != null) {
-                bn.c(se_Tag(value, context).n(_Ta));
-            }
-        },
-        And: (value) => {
-            if (input[_A] != null) {
-                bn.c(se_ReplicationRuleAndOperator(value, context).n(_A));
-            }
-        },
-        _: (name, value) => {
-            if (!(value instanceof __XmlNode || value instanceof __XmlText)) {
-                throw new Error("Unable to serialize unknown union members in XML.");
-            }
-            bn.c(new __XmlNode(name).c(value));
-        },
-    });
+    bn.cc(input, _P);
+    if (input[_Ta] != null) {
+        bn.c(se_Tag(input[_Ta], context).n(_Ta));
+    }
+    if (input[_A] != null) {
+        bn.c(se_ReplicationRuleAndOperator(input[_A], context).n(_A));
+    }
     return bn;
 };
 const se_ReplicationRules = (input, context) => {
@@ -4922,6 +5036,16 @@ const se_S3Location = (input, context) => {
     bn.cc(input, _SC);
     return bn;
 };
+const se_S3TablesDestination = (input, context) => {
+    const bn = new __XmlNode(_STD);
+    if (input[_TBA] != null) {
+        bn.c(__XmlNode.of(_STBA, input[_TBA]).n(_TBA));
+    }
+    if (input[_TN] != null) {
+        bn.c(__XmlNode.of(_STN, input[_TN]).n(_TN));
+    }
+    return bn;
+};
 const se_ScanRange = (input, context) => {
     const bn = new __XmlNode(_SR);
     if (input[_St] != null) {
@@ -5120,7 +5244,7 @@ const se_TopicConfigurationList = (input, context) => {
 const se_Transition = (input, context) => {
     const bn = new __XmlNode(_Tra);
     if (input[_Dat] != null) {
-        bn.c(__XmlNode.of(_Dat, (input[_Dat].toISOString().split(".")[0] + "Z").toString()).n(_Dat));
+        bn.c(__XmlNode.of(_Dat, __serializeDateTime(input[_Dat]).toString()).n(_Dat));
     }
     if (input[_Da] != null) {
         bn.c(__XmlNode.of(_Da, String(input[_Da])).n(_Da));
@@ -5289,6 +5413,9 @@ const de_Bucket = (output, context) => {
     if (output[_CDr] != null) {
         contents[_CDr] = __expectNonNull(__parseRfc3339DateTimeWithOffset(output[_CDr]));
     }
+    if (output[_BR] != null) {
+        contents[_BR] = __expectString(output[_BR]);
+    }
     return contents;
 };
 const de_Buckets = (output, context) => {
@@ -5555,6 +5682,16 @@ const de__Error = (output, context) => {
     }
     return contents;
 };
+const de_ErrorDetails = (output, context) => {
+    const contents = {};
+    if (output[_EC] != null) {
+        contents[_EC] = __expectString(output[_EC]);
+    }
+    if (output[_EM] != null) {
+        contents[_EM] = __expectString(output[_EM]);
+    }
+    return contents;
+};
 const de_ErrorDocument = (output, context) => {
     const contents = {};
     if (output[_K] != null) {
@@ -5611,6 +5748,19 @@ const de_FilterRuleList = (output, context) => {
         return de_FilterRule(entry, context);
     });
 };
+const de_GetBucketMetadataTableConfigurationResult = (output, context) => {
+    const contents = {};
+    if (output[_MTCR] != null) {
+        contents[_MTCR] = de_MetadataTableConfigurationResult(output[_MTCR], context);
+    }
+    if (output[_S] != null) {
+        contents[_S] = __expectString(output[_S]);
+    }
+    if (output[_Er] != null) {
+        contents[_Er] = de_ErrorDetails(output[_Er], context);
+    }
+    return contents;
+};
 const de_GetObjectAttributesParts = (output, context) => {
     const contents = {};
     if (output[_PC] != null) {
@@ -5883,10 +6033,8 @@ const de_LifecycleRule = (output, context) => {
     if (output[_P] != null) {
         contents[_P] = __expectString(output[_P]);
     }
-    if (output.Filter === "") {
-    }
-    else if (output[_F] != null) {
-        contents[_F] = de_LifecycleRuleFilter(__expectUnion(output[_F]), context);
+    if (output[_F] != null) {
+        contents[_F] = de_LifecycleRuleFilter(output[_F], context);
     }
     if (output[_S] != null) {
         contents[_S] = __expectString(output[_S]);
@@ -5931,32 +6079,23 @@ const de_LifecycleRuleAndOperator = (output, context) => {
     return contents;
 };
 const de_LifecycleRuleFilter = (output, context) => {
+    const contents = {};
     if (output[_P] != null) {
-        return {
-            Prefix: __expectString(output[_P]),
-        };
+        contents[_P] = __expectString(output[_P]);
     }
     if (output[_Ta] != null) {
-        return {
-            Tag: de_Tag(output[_Ta], context),
-        };
+        contents[_Ta] = de_Tag(output[_Ta], context);
     }
     if (output[_OSGT] != null) {
-        return {
-            ObjectSizeGreaterThan: __strictParseLong(output[_OSGT]),
-        };
+        contents[_OSGT] = __strictParseLong(output[_OSGT]);
     }
     if (output[_OSLT] != null) {
-        return {
-            ObjectSizeLessThan: __strictParseLong(output[_OSLT]),
-        };
+        contents[_OSLT] = __strictParseLong(output[_OSLT]);
     }
     if (output[_A] != null) {
-        return {
-            And: de_LifecycleRuleAndOperator(output[_A], context),
-        };
+        contents[_A] = de_LifecycleRuleAndOperator(output[_A], context);
     }
-    return { $unknown: Object.entries(output)[0] };
+    return contents;
 };
 const de_LifecycleRules = (output, context) => {
     return (output || [])
@@ -5984,6 +6123,13 @@ const de_LoggingEnabled = (output, context) => {
     }
     return contents;
 };
+const de_MetadataTableConfigurationResult = (output, context) => {
+    const contents = {};
+    if (output[_STDR] != null) {
+        contents[_STDR] = de_S3TablesDestinationResult(output[_STDR], context);
+    }
+    return contents;
+};
 const de_Metrics = (output, context) => {
     const contents = {};
     if (output[_S] != null) {
@@ -6464,10 +6610,8 @@ const de_ReplicationRule = (output, context) => {
     if (output[_P] != null) {
         contents[_P] = __expectString(output[_P]);
     }
-    if (output.Filter === "") {
-    }
-    else if (output[_F] != null) {
-        contents[_F] = de_ReplicationRuleFilter(__expectUnion(output[_F]), context);
+    if (output[_F] != null) {
+        contents[_F] = de_ReplicationRuleFilter(output[_F], context);
     }
     if (output[_S] != null) {
         contents[_S] = __expectString(output[_S]);
@@ -6500,22 +6644,17 @@ const de_ReplicationRuleAndOperator = (output, context) => {
     return contents;
 };
 const de_ReplicationRuleFilter = (output, context) => {
+    const contents = {};
     if (output[_P] != null) {
-        return {
-            Prefix: __expectString(output[_P]),
-        };
+        contents[_P] = __expectString(output[_P]);
     }
     if (output[_Ta] != null) {
-        return {
-            Tag: de_Tag(output[_Ta], context),
-        };
+        contents[_Ta] = de_Tag(output[_Ta], context);
     }
     if (output[_A] != null) {
-        return {
-            And: de_ReplicationRuleAndOperator(output[_A], context),
-        };
+        contents[_A] = de_ReplicationRuleAndOperator(output[_A], context);
     }
-    return { $unknown: Object.entries(output)[0] };
+    return contents;
 };
 const de_ReplicationRules = (output, context) => {
     return (output || [])
@@ -6578,6 +6717,22 @@ const de_S3KeyFilter = (output, context) => {
     }
     return contents;
 };
+const de_S3TablesDestinationResult = (output, context) => {
+    const contents = {};
+    if (output[_TBA] != null) {
+        contents[_TBA] = __expectString(output[_TBA]);
+    }
+    if (output[_TN] != null) {
+        contents[_TN] = __expectString(output[_TN]);
+    }
+    if (output[_TAa] != null) {
+        contents[_TAa] = __expectString(output[_TAa]);
+    }
+    if (output[_TNa] != null) {
+        contents[_TNa] = __expectString(output[_TNa]);
+    }
+    return contents;
+};
 const de_ServerSideEncryptionByDefault = (output, context) => {
     const contents = {};
     if (output[_SSEA] != null) {
@@ -6807,11 +6962,6 @@ const deserializeMetadata = (output) => ({
     cfId: output.headers["x-amz-cf-id"],
 });
 const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
-const isSerializableHeaderValue = (value) => value !== undefined &&
-    value !== null &&
-    value !== "" &&
-    (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
-    (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
 const _A = "And";
 const _AAO = "AnalyticsAndOperator";
 const _AC = "AnalyticsConfiguration";
@@ -7000,7 +7150,10 @@ const _II = "InventoryId";
 const _IIOV = "InventoryIncludedObjectVersions";
 const _IL = "IsLatest";
 const _IM = "IfMatch";
-const _IMS = "IfModifiedSince";
+const _IMIT = "IfMatchInitiatedTime";
+const _IMLMT = "IfMatchLastModifiedTime";
+const _IMS = "IfMatchSize";
+const _IMSf = "IfModifiedSince";
 const _INM = "IfNoneMatch";
 const _IOF = "InventoryOptionalField";
 const _IOV = "IncludedObjectVersions";
@@ -7043,6 +7196,7 @@ const _LFC = "LambdaFunctionConfigurations";
 const _LFCa = "LambdaFunctionConfiguration";
 const _LI = "LocationInfo";
 const _LM = "LastModified";
+const _LMT = "LastModifiedTime";
 const _LNAS = "LocationNameAsString";
 const _LP = "LocationPrefix";
 const _LR = "LifecycleRule";
@@ -7052,6 +7206,7 @@ const _LT = "LocationType";
 const _M = "Marker";
 const _MAO = "MetricsAndOperator";
 const _MAS = "MaxAgeSeconds";
+const _MB = "MaxBuckets";
 const _MC = "MetricsConfiguration";
 const _MCL = "MetricsConfigurationList";
 const _MD = "MetadataDirective";
@@ -7067,6 +7222,8 @@ const _MKe = "MetadataKey";
 const _MM = "MissingMeta";
 const _MP = "MaxParts";
 const _MS = "MetricsStatus";
+const _MTC = "MetadataTableConfiguration";
+const _MTCR = "MetadataTableConfigurationResult";
 const _MU = "MaxUploads";
 const _MV = "MetadataValue";
 const _Me = "Metrics";
@@ -7222,6 +7379,10 @@ const _SSEKMSKI = "SSEKMSKeyId";
 const _SSER = "ServerSideEncryptionRule";
 const _SSES = "SSES3";
 const _ST = "SessionToken";
+const _STBA = "S3TablesBucketArn";
+const _STD = "S3TablesDestination";
+const _STDR = "S3TablesDestinationResult";
+const _STN = "S3TablesName";
 const _S_ = "S3";
 const _Sc = "Schedule";
 const _Se = "Setting";
@@ -7230,13 +7391,18 @@ const _St = "Start";
 const _Su = "Suffix";
 const _T = "Tagging";
 const _TA = "TopicArn";
+const _TAa = "TableArn";
 const _TB = "TargetBucket";
+const _TBA = "TableBucketArn";
 const _TC = "TagCount";
 const _TCo = "TopicConfiguration";
 const _TCop = "TopicConfigurations";
 const _TD = "TaggingDirective";
+const _TDMOS = "TransitionDefaultMinimumObjectSize";
 const _TG = "TargetGrants";
 const _TGa = "TargetGrant";
+const _TN = "TableName";
+const _TNa = "TableNamespace";
 const _TOKF = "TargetObjectKeyFormat";
 const _TP = "TargetPrefix";
 const _TPC = "TotalPartsCount";
@@ -7267,6 +7433,7 @@ const _VIM = "VersionIdMarker";
 const _Va = "Value";
 const _Ve = "Versions";
 const _WC = "WebsiteConfiguration";
+const _WOB = "WriteOffsetBytes";
 const _WRL = "WebsiteRedirectLocation";
 const _Y = "Years";
 const _a = "analytics";
@@ -7274,6 +7441,7 @@ const _ac = "accelerate";
 const _acl = "acl";
 const _ar = "accept-ranges";
 const _at = "attributes";
+const _br = "bucket-region";
 const _c = "cors";
 const _cc = "cache-control";
 const _cd = "content-disposition";
@@ -7307,7 +7475,9 @@ const _lo = "location";
 const _log = "logging";
 const _lt = "list-type";
 const _m = "metrics";
+const _mT = "metadataTable";
 const _ma = "marker";
+const _mb = "max-buckets";
 const _mdb = "max-directory-buckets";
 const _me = "member";
 const _mk = "max-keys";
@@ -7421,6 +7591,9 @@ const _xagr = "x-amz-grant-read";
 const _xagra = "x-amz-grant-read-acp";
 const _xagw = "x-amz-grant-write";
 const _xagwa = "x-amz-grant-write-acp";
+const _xaimit = "x-amz-if-match-initiated-time";
+const _xaimlmt = "x-amz-if-match-last-modified-time";
+const _xaims = "x-amz-if-match-size";
 const _xam = "x-amz-mfa";
 const _xamd = "x-amz-metadata-directive";
 const _xamm = "x-amz-missing-meta";
@@ -7432,6 +7605,7 @@ const _xaolm = "x-amz-object-lock-mode";
 const _xaolrud = "x-amz-object-lock-retain-until-date";
 const _xaoo = "x-amz-object-ownership";
 const _xaooa = "x-amz-optional-object-attributes";
+const _xaos = "x-amz-object-size";
 const _xapnm = "x-amz-part-number-marker";
 const _xar = "x-amz-restore";
 const _xarc = "x-amz-request-charged";
@@ -7454,46 +7628,8 @@ const _xasseckm = "x-amz-server-side-encryption-customer-key-md5";
 const _xat = "x-amz-tagging";
 const _xatc = "x-amz-tagging-count";
 const _xatd = "x-amz-tagging-directive";
+const _xatdmos = "x-amz-transition-default-minimum-object-size";
 const _xavi = "x-amz-version-id";
+const _xawob = "x-amz-write-offset-bytes";
 const _xawrl = "x-amz-website-redirect-location";
 const _xi = "x-id";
-const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
-    if (encoded.length) {
-        const parser = new XMLParser({
-            attributeNamePrefix: "",
-            htmlEntities: true,
-            ignoreAttributes: false,
-            ignoreDeclaration: true,
-            parseTagValue: false,
-            trimValues: false,
-            tagValueProcessor: (_, val) => (val.trim() === "" && val.includes("\n") ? "" : undefined),
-        });
-        parser.addEntity("#xD", "\r");
-        parser.addEntity("#10", "\n");
-        const parsedObj = parser.parse(encoded);
-        const textNodeName = "#text";
-        const key = Object.keys(parsedObj)[0];
-        const parsedObjToReturn = parsedObj[key];
-        if (parsedObjToReturn[textNodeName]) {
-            parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
-            delete parsedObjToReturn[textNodeName];
-        }
-        return __getValueFromTextNode(parsedObjToReturn);
-    }
-    return {};
-});
-const parseErrorBody = async (errorBody, context) => {
-    const value = await parseBody(errorBody, context);
-    if (value.Error) {
-        value.Error.message = value.Error.message ?? value.Error.Message;
-    }
-    return value;
-};
-const loadRestXmlErrorCode = (output, data) => {
-    if (data?.Code !== undefined) {
-        return data.Code;
-    }
-    if (output.statusCode == 404) {
-        return "NotFound";
-    }
-};