@aws-sdk/client-s3-control 3.288.0 → 3.290.0

package/dist-es/protocols/Aws_restXml.js

@@ -465,6 +465,35 @@ export const serializeAws_restXmlDeleteBucketPolicyCommand = async (input, conte
         body,
     });
 };
+export const serializeAws_restXmlDeleteBucketReplicationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = map({}, isSerializableHeaderValue, {
+        "x-amz-account-id": input.AccountId,
+    });
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20180820/bucket/{Bucket}/replication";
+    resolvedPath = __resolvedPath(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "{AccountId}." + resolvedHostname;
+        if (input.AccountId === undefined) {
+            throw new Error("Empty value provided for input host prefix: AccountId.");
+        }
+        resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new __HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restXmlDeleteBucketTaggingCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
@@ -1009,6 +1038,35 @@ export const serializeAws_restXmlGetBucketPolicyCommand = async (input, context)
         body,
     });
 };
+export const serializeAws_restXmlGetBucketReplicationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = map({}, isSerializableHeaderValue, {
+        "x-amz-account-id": input.AccountId,
+    });
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20180820/bucket/{Bucket}/replication";
+    resolvedPath = __resolvedPath(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "{AccountId}." + resolvedHostname;
+        if (input.AccountId === undefined) {
+            throw new Error("Empty value provided for input host prefix: AccountId.");
+        }
+        resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new __HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restXmlGetBucketTaggingCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
@@ -1699,6 +1757,46 @@ export const serializeAws_restXmlPutBucketPolicyCommand = async (input, context)
         body,
     });
 };
+export const serializeAws_restXmlPutBucketReplicationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/xml",
+        "x-amz-account-id": input.AccountId,
+    });
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20180820/bucket/{Bucket}/replication";
+    resolvedPath = __resolvedPath(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
+    let body;
+    if (input.ReplicationConfiguration !== undefined) {
+        body = serializeAws_restXmlReplicationConfiguration(input.ReplicationConfiguration, context);
+    }
+    let contents;
+    if (input.ReplicationConfiguration !== undefined) {
+        contents = serializeAws_restXmlReplicationConfiguration(input.ReplicationConfiguration, context);
+        body = '<?xml version="1.0" encoding="UTF-8"?>';
+        contents.addAttribute("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
+        body += contents.toString();
+    }
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "{AccountId}." + resolvedHostname;
+        if (input.AccountId === undefined) {
+            throw new Error("Empty value provided for input host prefix: AccountId.");
+        }
+        resolvedHostname = resolvedHostname.replace("{AccountId}", input.AccountId);
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    return new __HttpRequest({
+        protocol,
+        hostname: resolvedHostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restXmlPutBucketTaggingCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
@@ -2434,6 +2532,30 @@ const deserializeAws_restXmlDeleteBucketPolicyCommandError = async (output, cont
         errorCode,
     });
 };
+export const deserializeAws_restXmlDeleteBucketReplicationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restXmlDeleteBucketReplicationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restXmlDeleteBucketReplicationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
 export const deserializeAws_restXmlDeleteBucketTaggingCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
         return deserializeAws_restXmlDeleteBucketTaggingCommandError(output, context);
@@ -2977,6 +3099,33 @@ const deserializeAws_restXmlGetBucketPolicyCommandError = async (output, context
         errorCode,
     });
 };
+export const deserializeAws_restXmlGetBucketReplicationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restXmlGetBucketReplicationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data["ReplicationConfiguration"] !== undefined) {
+        contents.ReplicationConfiguration = deserializeAws_restXmlReplicationConfiguration(data["ReplicationConfiguration"], context);
+    }
+    return contents;
+};
+const deserializeAws_restXmlGetBucketReplicationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
 export const deserializeAws_restXmlGetBucketTaggingCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restXmlGetBucketTaggingCommandError(output, context);
@@ -3610,6 +3759,30 @@ const deserializeAws_restXmlPutBucketPolicyCommandError = async (output, context
         errorCode,
     });
 };
+export const deserializeAws_restXmlPutBucketReplicationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restXmlPutBucketReplicationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restXmlPutBucketReplicationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
 export const deserializeAws_restXmlPutBucketTaggingCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restXmlPutBucketTaggingCommandError(output, context);
@@ -4063,6 +4236,14 @@ const serializeAws_restXmlAbortIncompleteMultipartUpload = (input, context) => {
     }
     return bodyNode;
 };
+const serializeAws_restXmlAccessControlTranslation = (input, context) => {
+    const bodyNode = new __XmlNode("AccessControlTranslation");
+    if (input.Owner != null) {
+        const node = __XmlNode.of("OwnerOverride", input.Owner).withName("Owner");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const serializeAws_restXmlAccountLevel = (input, context) => {
     const bodyNode = new __XmlNode("AccountLevel");
     if (input.ActivityMetrics != null) {
@@ -4191,6 +4372,14 @@ const serializeAws_restXmlCreateMultiRegionAccessPointInput = (input, context) =
     }
     return bodyNode;
 };
+const serializeAws_restXmlDeleteMarkerReplication = (input, context) => {
+    const bodyNode = new __XmlNode("DeleteMarkerReplication");
+    if (input.Status != null) {
+        const node = __XmlNode.of("DeleteMarkerReplicationStatus", input.Status).withName("Status");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const serializeAws_restXmlDeleteMultiRegionAccessPointInput = (input, context) => {
     const bodyNode = new __XmlNode("DeleteMultiRegionAccessPointInput");
     if (input.Name != null) {
@@ -4199,6 +4388,38 @@ const serializeAws_restXmlDeleteMultiRegionAccessPointInput = (input, context) =
     }
     return bodyNode;
 };
+const serializeAws_restXmlDestination = (input, context) => {
+    const bodyNode = new __XmlNode("Destination");
+    if (input.Account != null) {
+        const node = __XmlNode.of("AccountId", input.Account).withName("Account");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Bucket != null) {
+        const node = __XmlNode.of("BucketIdentifierString", input.Bucket).withName("Bucket");
+        bodyNode.addChildNode(node);
+    }
+    if (input.ReplicationTime != null) {
+        const node = serializeAws_restXmlReplicationTime(input.ReplicationTime, context).withName("ReplicationTime");
+        bodyNode.addChildNode(node);
+    }
+    if (input.AccessControlTranslation != null) {
+        const node = serializeAws_restXmlAccessControlTranslation(input.AccessControlTranslation, context).withName("AccessControlTranslation");
+        bodyNode.addChildNode(node);
+    }
+    if (input.EncryptionConfiguration != null) {
+        const node = serializeAws_restXmlEncryptionConfiguration(input.EncryptionConfiguration, context).withName("EncryptionConfiguration");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Metrics != null) {
+        const node = serializeAws_restXmlMetrics(input.Metrics, context).withName("Metrics");
+        bodyNode.addChildNode(node);
+    }
+    if (input.StorageClass != null) {
+        const node = __XmlNode.of("ReplicationStorageClass", input.StorageClass).withName("StorageClass");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const serializeAws_restXmlDetailedStatusCodesMetrics = (input, context) => {
     const bodyNode = new __XmlNode("DetailedStatusCodesMetrics");
     if (input.IsEnabled != null) {
@@ -4207,6 +4428,14 @@ const serializeAws_restXmlDetailedStatusCodesMetrics = (input, context) => {
     }
     return bodyNode;
 };
+const serializeAws_restXmlEncryptionConfiguration = (input, context) => {
+    const bodyNode = new __XmlNode("EncryptionConfiguration");
+    if (input.ReplicaKmsKeyID != null) {
+        const node = __XmlNode.of("ReplicaKmsKeyID", input.ReplicaKmsKeyID).withName("ReplicaKmsKeyID");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const serializeAws_restXml_Exclude = (input, context) => {
     const bodyNode = new __XmlNode("Exclude");
     if (input.Buckets != null) {
@@ -4227,6 +4456,14 @@ const serializeAws_restXml_Exclude = (input, context) => {
     }
     return bodyNode;
 };
+const serializeAws_restXmlExistingObjectReplication = (input, context) => {
+    const bodyNode = new __XmlNode("ExistingObjectReplication");
+    if (input.Status != null) {
+        const node = __XmlNode.of("ExistingObjectReplicationStatus", input.Status).withName("Status");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const serializeAws_restXmlGeneratedManifestEncryption = (input, context) => {
     const bodyNode = new __XmlNode("GeneratedManifestEncryption");
     if (input.SSES3 != null) {
@@ -4565,6 +4802,18 @@ const serializeAws_restXmlLifecycleRules = (input, context) => {
         return node.withName("Rule");
     });
 };
+const serializeAws_restXmlMetrics = (input, context) => {
+    const bodyNode = new __XmlNode("Metrics");
+    if (input.Status != null) {
+        const node = __XmlNode.of("MetricsStatus", input.Status).withName("Status");
+        bodyNode.addChildNode(node);
+    }
+    if (input.EventThreshold != null) {
+        const node = serializeAws_restXmlReplicationTimeValue(input.EventThreshold, context).withName("EventThreshold");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const serializeAws_restXmlMultiRegionAccessPointRoute = (input, context) => {
     const bodyNode = new __XmlNode("MultiRegionAccessPointRoute");
     if (input.Bucket != null) {
@@ -4761,6 +5010,10 @@ const serializeAws_restXmlRegion = (input, context) => {
         const node = __XmlNode.of("BucketName", input.Bucket).withName("Bucket");
         bodyNode.addChildNode(node);
     }
+    if (input.BucketAccountId != null) {
+        const node = __XmlNode.of("AccountId", input.BucketAccountId).withName("BucketAccountId");
+        bodyNode.addChildNode(node);
+    }
     return bodyNode;
 };
 const serializeAws_restXmlRegionCreationList = (input, context) => {
@@ -4779,6 +5032,114 @@ const serializeAws_restXmlRegions = (input, context) => {
         return node.withName("Region");
     });
 };
+const serializeAws_restXmlReplicaModifications = (input, context) => {
+    const bodyNode = new __XmlNode("ReplicaModifications");
+    if (input.Status != null) {
+        const node = __XmlNode.of("ReplicaModificationsStatus", input.Status).withName("Status");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
+const serializeAws_restXmlReplicationConfiguration = (input, context) => {
+    const bodyNode = new __XmlNode("ReplicationConfiguration");
+    if (input.Role != null) {
+        const node = __XmlNode.of("Role", input.Role).withName("Role");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Rules != null) {
+        const nodes = serializeAws_restXmlReplicationRules(input.Rules, context);
+        const containerNode = new __XmlNode("Rules");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    return bodyNode;
+};
+const serializeAws_restXmlReplicationRule = (input, context) => {
+    const bodyNode = new __XmlNode("ReplicationRule");
+    if (input.ID != null) {
+        const node = __XmlNode.of("ID", input.ID).withName("ID");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Priority != null) {
+        const node = __XmlNode.of("Priority", String(input.Priority)).withName("Priority");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Prefix != null) {
+        const node = __XmlNode.of("Prefix", input.Prefix).withName("Prefix");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Filter != null) {
+        const node = serializeAws_restXmlReplicationRuleFilter(input.Filter, context).withName("Filter");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Status != null) {
+        const node = __XmlNode.of("ReplicationRuleStatus", input.Status).withName("Status");
+        bodyNode.addChildNode(node);
+    }
+    if (input.SourceSelectionCriteria != null) {
+        const node = serializeAws_restXmlSourceSelectionCriteria(input.SourceSelectionCriteria, context).withName("SourceSelectionCriteria");
+        bodyNode.addChildNode(node);
+    }
+    if (input.ExistingObjectReplication != null) {
+        const node = serializeAws_restXmlExistingObjectReplication(input.ExistingObjectReplication, context).withName("ExistingObjectReplication");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Destination != null) {
+        const node = serializeAws_restXmlDestination(input.Destination, context).withName("Destination");
+        bodyNode.addChildNode(node);
+    }
+    if (input.DeleteMarkerReplication != null) {
+        const node = serializeAws_restXmlDeleteMarkerReplication(input.DeleteMarkerReplication, context).withName("DeleteMarkerReplication");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Bucket != null) {
+        const node = __XmlNode.of("BucketIdentifierString", input.Bucket).withName("Bucket");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
+const serializeAws_restXmlReplicationRuleAndOperator = (input, context) => {
+    const bodyNode = new __XmlNode("ReplicationRuleAndOperator");
+    if (input.Prefix != null) {
+        const node = __XmlNode.of("Prefix", input.Prefix).withName("Prefix");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Tags != null) {
+        const nodes = serializeAws_restXmlS3TagSet(input.Tags, context);
+        const containerNode = new __XmlNode("Tags");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    return bodyNode;
+};
+const serializeAws_restXmlReplicationRuleFilter = (input, context) => {
+    const bodyNode = new __XmlNode("ReplicationRuleFilter");
+    if (input.Prefix != null) {
+        const node = __XmlNode.of("Prefix", input.Prefix).withName("Prefix");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Tag != null) {
+        const node = serializeAws_restXmlS3Tag(input.Tag, context).withName("Tag");
+        bodyNode.addChildNode(node);
+    }
+    if (input.And != null) {
+        const node = serializeAws_restXmlReplicationRuleAndOperator(input.And, context).withName("And");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
+const serializeAws_restXmlReplicationRules = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        const node = serializeAws_restXmlReplicationRule(entry, context);
+        return node.withName("Rule");
+    });
+};
 const serializeAws_restXmlReplicationStatusFilterList = (input, context) => {
     return input
         .filter((e) => e != null)
@@ -4787,6 +5148,26 @@ const serializeAws_restXmlReplicationStatusFilterList = (input, context) => {
         return node.withName("member");
     });
 };
+const serializeAws_restXmlReplicationTime = (input, context) => {
+    const bodyNode = new __XmlNode("ReplicationTime");
+    if (input.Status != null) {
+        const node = __XmlNode.of("ReplicationTimeStatus", input.Status).withName("Status");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Time != null) {
+        const node = serializeAws_restXmlReplicationTimeValue(input.Time, context).withName("Time");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
+const serializeAws_restXmlReplicationTimeValue = (input, context) => {
+    const bodyNode = new __XmlNode("ReplicationTimeValue");
+    if (input.Minutes != null) {
+        const node = __XmlNode.of("Minutes", String(input.Minutes)).withName("Minutes");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const serializeAws_restXmlRouteList = (input, context) => {
     return input
         .filter((e) => e != null)
@@ -5230,6 +5611,18 @@ const serializeAws_restXmlSelectionCriteria = (input, context) => {
     }
     return bodyNode;
 };
+const serializeAws_restXmlSourceSelectionCriteria = (input, context) => {
+    const bodyNode = new __XmlNode("SourceSelectionCriteria");
+    if (input.SseKmsEncryptedObjects != null) {
+        const node = serializeAws_restXmlSseKmsEncryptedObjects(input.SseKmsEncryptedObjects, context).withName("SseKmsEncryptedObjects");
+        bodyNode.addChildNode(node);
+    }
+    if (input.ReplicaModifications != null) {
+        const node = serializeAws_restXmlReplicaModifications(input.ReplicaModifications, context).withName("ReplicaModifications");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const serializeAws_restXmlSSEKMS = (input, context) => {
     const bodyNode = new __XmlNode("SSE-KMS");
     if (input.KeyId != null) {
@@ -5238,6 +5631,14 @@ const serializeAws_restXmlSSEKMS = (input, context) => {
     }
     return bodyNode;
 };
+const serializeAws_restXmlSseKmsEncryptedObjects = (input, context) => {
+    const bodyNode = new __XmlNode("SseKmsEncryptedObjects");
+    if (input.Status != null) {
+        const node = __XmlNode.of("SseKmsEncryptedObjectsStatus", input.Status).withName("Status");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const serializeAws_restXmlSSEKMSEncryption = (input, context) => {
     const bodyNode = new __XmlNode("SSE-KMS");
     if (input.KeyId != null) {
@@ -5407,6 +5808,15 @@ const deserializeAws_restXmlAbortIncompleteMultipartUpload = (output, context) =
     }
     return contents;
 };
+const deserializeAws_restXmlAccessControlTranslation = (output, context) => {
+    const contents = {
+        Owner: undefined,
+    };
+    if (output["Owner"] !== undefined) {
+        contents.Owner = __expectString(output["Owner"]);
+    }
+    return contents;
+};
 const deserializeAws_restXmlAccessPoint = (output, context) => {
     const contents = {
         Name: undefined,
@@ -5653,6 +6063,15 @@ const deserializeAws_restXmlCreateMultiRegionAccessPointInput = (output, context
     }
     return contents;
 };
+const deserializeAws_restXmlDeleteMarkerReplication = (output, context) => {
+    const contents = {
+        Status: undefined,
+    };
+    if (output["Status"] !== undefined) {
+        contents.Status = __expectString(output["Status"]);
+    }
+    return contents;
+};
 const deserializeAws_restXmlDeleteMultiRegionAccessPointInput = (output, context) => {
     const contents = {
         Name: undefined,
@@ -5662,6 +6081,39 @@ const deserializeAws_restXmlDeleteMultiRegionAccessPointInput = (output, context
     }
     return contents;
 };
+const deserializeAws_restXmlDestination = (output, context) => {
+    const contents = {
+        Account: undefined,
+        Bucket: undefined,
+        ReplicationTime: undefined,
+        AccessControlTranslation: undefined,
+        EncryptionConfiguration: undefined,
+        Metrics: undefined,
+        StorageClass: undefined,
+    };
+    if (output["Account"] !== undefined) {
+        contents.Account = __expectString(output["Account"]);
+    }
+    if (output["Bucket"] !== undefined) {
+        contents.Bucket = __expectString(output["Bucket"]);
+    }
+    if (output["ReplicationTime"] !== undefined) {
+        contents.ReplicationTime = deserializeAws_restXmlReplicationTime(output["ReplicationTime"], context);
+    }
+    if (output["AccessControlTranslation"] !== undefined) {
+        contents.AccessControlTranslation = deserializeAws_restXmlAccessControlTranslation(output["AccessControlTranslation"], context);
+    }
+    if (output["EncryptionConfiguration"] !== undefined) {
+        contents.EncryptionConfiguration = deserializeAws_restXmlEncryptionConfiguration(output["EncryptionConfiguration"], context);
+    }
+    if (output["Metrics"] !== undefined) {
+        contents.Metrics = deserializeAws_restXmlMetrics(output["Metrics"], context);
+    }
+    if (output["StorageClass"] !== undefined) {
+        contents.StorageClass = __expectString(output["StorageClass"]);
+    }
+    return contents;
+};
 const deserializeAws_restXmlDetailedStatusCodesMetrics = (output, context) => {
     const contents = {
         IsEnabled: undefined,
@@ -5671,6 +6123,15 @@ const deserializeAws_restXmlDetailedStatusCodesMetrics = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_restXmlEncryptionConfiguration = (output, context) => {
+    const contents = {
+        ReplicaKmsKeyID: undefined,
+    };
+    if (output["ReplicaKmsKeyID"] !== undefined) {
+        contents.ReplicaKmsKeyID = __expectString(output["ReplicaKmsKeyID"]);
+    }
+    return contents;
+};
 const deserializeAws_restXmlEndpoints = (output, context) => {
     return output.reduce((acc, pair) => {
         if (pair["value"] === null) {
@@ -5708,6 +6169,15 @@ const deserializeAws_restXml_Exclude = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_restXmlExistingObjectReplication = (output, context) => {
+    const contents = {
+        Status: undefined,
+    };
+    if (output["Status"] !== undefined) {
+        contents.Status = __expectString(output["Status"]);
+    }
+    return contents;
+};
 const deserializeAws_restXmlGeneratedManifestEncryption = (output, context) => {
     const contents = {
         SSES3: undefined,
@@ -6219,6 +6689,19 @@ const deserializeAws_restXmlListStorageLensConfigurationEntry = (output, context
     }
     return contents;
 };
+const deserializeAws_restXmlMetrics = (output, context) => {
+    const contents = {
+        Status: undefined,
+        EventThreshold: undefined,
+    };
+    if (output["Status"] !== undefined) {
+        contents.Status = __expectString(output["Status"]);
+    }
+    if (output["EventThreshold"] !== undefined) {
+        contents.EventThreshold = deserializeAws_restXmlReplicationTimeValue(output["EventThreshold"], context);
+    }
+    return contents;
+};
 const deserializeAws_restXmlMultiRegionAccessPointPolicyDocument = (output, context) => {
     const contents = {
         Established: undefined,
@@ -6525,10 +7008,14 @@ const deserializeAws_restXmlPutMultiRegionAccessPointPolicyInput = (output, cont
 const deserializeAws_restXmlRegion = (output, context) => {
     const contents = {
         Bucket: undefined,
+        BucketAccountId: undefined,
     };
     if (output["Bucket"] !== undefined) {
         contents.Bucket = __expectString(output["Bucket"]);
     }
+    if (output["BucketAccountId"] !== undefined) {
+        contents.BucketAccountId = __expectString(output["BucketAccountId"]);
+    }
     return contents;
 };
 const deserializeAws_restXmlRegionalBucket = (output, context) => {
@@ -6574,6 +7061,7 @@ const deserializeAws_restXmlRegionReport = (output, context) => {
     const contents = {
         Bucket: undefined,
         Region: undefined,
+        BucketAccountId: undefined,
     };
     if (output["Bucket"] !== undefined) {
         contents.Bucket = __expectString(output["Bucket"]);
@@ -6581,6 +7069,9 @@ const deserializeAws_restXmlRegionReport = (output, context) => {
     if (output["Region"] !== undefined) {
         contents.Region = __expectString(output["Region"]);
     }
+    if (output["BucketAccountId"] !== undefined) {
+        contents.BucketAccountId = __expectString(output["BucketAccountId"]);
+    }
     return contents;
 };
 const deserializeAws_restXmlRegionReportList = (output, context) => {
@@ -6597,6 +7088,116 @@ const deserializeAws_restXmlRegions = (output, context) => {
         return __expectString(entry);
     });
 };
+const deserializeAws_restXmlReplicaModifications = (output, context) => {
+    const contents = {
+        Status: undefined,
+    };
+    if (output["Status"] !== undefined) {
+        contents.Status = __expectString(output["Status"]);
+    }
+    return contents;
+};
+const deserializeAws_restXmlReplicationConfiguration = (output, context) => {
+    const contents = {
+        Role: undefined,
+        Rules: undefined,
+    };
+    if (output["Role"] !== undefined) {
+        contents.Role = __expectString(output["Role"]);
+    }
+    if (output.Rules === "") {
+        contents.Rules = [];
+    }
+    else if (output["Rules"] !== undefined && output["Rules"]["Rule"] !== undefined) {
+        contents.Rules = deserializeAws_restXmlReplicationRules(__getArrayIfSingleItem(output["Rules"]["Rule"]), context);
+    }
+    return contents;
+};
+const deserializeAws_restXmlReplicationRule = (output, context) => {
+    const contents = {
+        ID: undefined,
+        Priority: undefined,
+        Prefix: undefined,
+        Filter: undefined,
+        Status: undefined,
+        SourceSelectionCriteria: undefined,
+        ExistingObjectReplication: undefined,
+        Destination: undefined,
+        DeleteMarkerReplication: undefined,
+        Bucket: undefined,
+    };
+    if (output["ID"] !== undefined) {
+        contents.ID = __expectString(output["ID"]);
+    }
+    if (output["Priority"] !== undefined) {
+        contents.Priority = __strictParseInt32(output["Priority"]);
+    }
+    if (output["Prefix"] !== undefined) {
+        contents.Prefix = __expectString(output["Prefix"]);
+    }
+    if (output["Filter"] !== undefined) {
+        contents.Filter = deserializeAws_restXmlReplicationRuleFilter(output["Filter"], context);
+    }
+    if (output["Status"] !== undefined) {
+        contents.Status = __expectString(output["Status"]);
+    }
+    if (output["SourceSelectionCriteria"] !== undefined) {
+        contents.SourceSelectionCriteria = deserializeAws_restXmlSourceSelectionCriteria(output["SourceSelectionCriteria"], context);
+    }
+    if (output["ExistingObjectReplication"] !== undefined) {
+        contents.ExistingObjectReplication = deserializeAws_restXmlExistingObjectReplication(output["ExistingObjectReplication"], context);
+    }
+    if (output["Destination"] !== undefined) {
+        contents.Destination = deserializeAws_restXmlDestination(output["Destination"], context);
+    }
+    if (output["DeleteMarkerReplication"] !== undefined) {
+        contents.DeleteMarkerReplication = deserializeAws_restXmlDeleteMarkerReplication(output["DeleteMarkerReplication"], context);
+    }
+    if (output["Bucket"] !== undefined) {
+        contents.Bucket = __expectString(output["Bucket"]);
+    }
+    return contents;
+};
+const deserializeAws_restXmlReplicationRuleAndOperator = (output, context) => {
+    const contents = {
+        Prefix: undefined,
+        Tags: undefined,
+    };
+    if (output["Prefix"] !== undefined) {
+        contents.Prefix = __expectString(output["Prefix"]);
+    }
+    if (output.Tags === "") {
+        contents.Tags = [];
+    }
+    else if (output["Tags"] !== undefined && output["Tags"]["member"] !== undefined) {
+        contents.Tags = deserializeAws_restXmlS3TagSet(__getArrayIfSingleItem(output["Tags"]["member"]), context);
+    }
+    return contents;
+};
+const deserializeAws_restXmlReplicationRuleFilter = (output, context) => {
+    const contents = {
+        Prefix: undefined,
+        Tag: undefined,
+        And: undefined,
+    };
+    if (output["Prefix"] !== undefined) {
+        contents.Prefix = __expectString(output["Prefix"]);
+    }
+    if (output["Tag"] !== undefined) {
+        contents.Tag = deserializeAws_restXmlS3Tag(output["Tag"], context);
+    }
+    if (output["And"] !== undefined) {
+        contents.And = deserializeAws_restXmlReplicationRuleAndOperator(output["And"], context);
+    }
+    return contents;
+};
+const deserializeAws_restXmlReplicationRules = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_restXmlReplicationRule(entry, context);
+    });
+};
 const deserializeAws_restXmlReplicationStatusFilterList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
@@ -6604,6 +7205,28 @@ const deserializeAws_restXmlReplicationStatusFilterList = (output, context) => {
         return __expectString(entry);
     });
 };
+const deserializeAws_restXmlReplicationTime = (output, context) => {
+    const contents = {
+        Status: undefined,
+        Time: undefined,
+    };
+    if (output["Status"] !== undefined) {
+        contents.Status = __expectString(output["Status"]);
+    }
+    if (output["Time"] !== undefined) {
+        contents.Time = deserializeAws_restXmlReplicationTimeValue(output["Time"], context);
+    }
+    return contents;
+};
+const deserializeAws_restXmlReplicationTimeValue = (output, context) => {
+    const contents = {
+        Minutes: undefined,
+    };
+    if (output["Minutes"] !== undefined) {
+        contents.Minutes = __strictParseInt32(output["Minutes"]);
+    }
+    return contents;
+};
 const deserializeAws_restXmlRouteList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
@@ -7049,6 +7672,19 @@ const deserializeAws_restXmlSelectionCriteria = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_restXmlSourceSelectionCriteria = (output, context) => {
+    const contents = {
+        SseKmsEncryptedObjects: undefined,
+        ReplicaModifications: undefined,
+    };
+    if (output["SseKmsEncryptedObjects"] !== undefined) {
+        contents.SseKmsEncryptedObjects = deserializeAws_restXmlSseKmsEncryptedObjects(output["SseKmsEncryptedObjects"], context);
+    }
+    if (output["ReplicaModifications"] !== undefined) {
+        contents.ReplicaModifications = deserializeAws_restXmlReplicaModifications(output["ReplicaModifications"], context);
+    }
+    return contents;
+};
 const deserializeAws_restXmlSSEKMS = (output, context) => {
     const contents = {
         KeyId: undefined,
@@ -7058,6 +7694,15 @@ const deserializeAws_restXmlSSEKMS = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_restXmlSseKmsEncryptedObjects = (output, context) => {
+    const contents = {
+        Status: undefined,
+    };
+    if (output["Status"] !== undefined) {
+        contents.Status = __expectString(output["Status"]);
+    }
+    return contents;
+};
 const deserializeAws_restXmlSSEKMSEncryption = (output, context) => {
     const contents = {
         KeyId: undefined,