@aws-sdk/client-s3-control 3.48.0 → 3.52.0

package/dist-cjs/protocols/Aws_restXml.js

@@ -199,6 +199,10 @@ const serializeAws_restXmlCreateJobCommand = async (input, context) => {
         const node = serializeAws_restXmlJobManifest(input.Manifest, context).withName("Manifest");
         bodyNode.addChildNode(node);
     }
+    if (input.ManifestGenerator !== undefined) {
+        const node = serializeAws_restXmlJobManifestGenerator(input.ManifestGenerator, context).withName("ManifestGenerator");
+        bodyNode.addChildNode(node);
+    }
     if (input.Operation !== undefined) {
         const node = serializeAws_restXmlJobOperation(input.Operation, context).withName("Operation");
         bodyNode.addChildNode(node);
@@ -5284,6 +5288,18 @@ const serializeAws_restXml_Exclude = (input, context) => {
     }
     return bodyNode;
 };
+const serializeAws_restXmlGeneratedManifestEncryption = (input, context) => {
+    const bodyNode = new xml_builder_1.XmlNode("GeneratedManifestEncryption");
+    if (input.SSES3 !== undefined && input.SSES3 !== null) {
+        const node = serializeAws_restXmlSSES3Encryption(input.SSES3, context).withName("SSE-S3");
+        bodyNode.addChildNode(node);
+    }
+    if (input.SSEKMS !== undefined && input.SSEKMS !== null) {
+        const node = serializeAws_restXmlSSEKMSEncryption(input.SSEKMS, context).withName("SSE-KMS");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const serializeAws_restXmlInclude = (input, context) => {
     const bodyNode = new xml_builder_1.XmlNode("Include");
     if (input.Buckets !== undefined && input.Buckets !== null) {
@@ -5327,6 +5343,52 @@ const serializeAws_restXmlJobManifestFieldList = (input, context) => {
         return node.withName("member");
     });
 };
+const serializeAws_restXmlJobManifestGenerator = (input, context) => {
+    const bodyNode = new xml_builder_1.XmlNode("JobManifestGenerator");
+    models_0_1.JobManifestGenerator.visit(input, {
+        S3JobManifestGenerator: (value) => {
+            const node = serializeAws_restXmlS3JobManifestGenerator(value, context).withName("S3JobManifestGenerator");
+            bodyNode.addChildNode(node);
+        },
+        _: (name, value) => {
+            if (!(value instanceof xml_builder_1.XmlNode || value instanceof xml_builder_1.XmlText)) {
+                throw new Error("Unable to serialize unknown union members in XML.");
+            }
+            bodyNode.addChildNode(new xml_builder_1.XmlNode(name).addChildNode(value));
+        },
+    });
+    return bodyNode;
+};
+const serializeAws_restXmlJobManifestGeneratorFilter = (input, context) => {
+    const bodyNode = new xml_builder_1.XmlNode("JobManifestGeneratorFilter");
+    if (input.EligibleForReplication !== undefined && input.EligibleForReplication !== null) {
+        const node = new xml_builder_1.XmlNode("Boolean")
+            .addChildNode(new xml_builder_1.XmlText(String(input.EligibleForReplication)))
+            .withName("EligibleForReplication");
+        bodyNode.addChildNode(node);
+    }
+    if (input.CreatedAfter !== undefined && input.CreatedAfter !== null) {
+        const node = new xml_builder_1.XmlNode("ObjectCreationTime")
+            .addChildNode(new xml_builder_1.XmlText(input.CreatedAfter.toISOString().split(".")[0] + "Z"))
+            .withName("CreatedAfter");
+        bodyNode.addChildNode(node);
+    }
+    if (input.CreatedBefore !== undefined && input.CreatedBefore !== null) {
+        const node = new xml_builder_1.XmlNode("ObjectCreationTime")
+            .addChildNode(new xml_builder_1.XmlText(input.CreatedBefore.toISOString().split(".")[0] + "Z"))
+            .withName("CreatedBefore");
+        bodyNode.addChildNode(node);
+    }
+    if (input.ObjectReplicationStatuses !== undefined && input.ObjectReplicationStatuses !== null) {
+        const nodes = serializeAws_restXmlReplicationStatusFilterList(input.ObjectReplicationStatuses, context);
+        const containerNode = new xml_builder_1.XmlNode("ObjectReplicationStatuses");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    return bodyNode;
+};
 const serializeAws_restXmlJobManifestLocation = (input, context) => {
     const bodyNode = new xml_builder_1.XmlNode("JobManifestLocation");
     if (input.ObjectArn !== undefined && input.ObjectArn !== null) {
@@ -5395,6 +5457,10 @@ const serializeAws_restXmlJobOperation = (input, context) => {
         const node = serializeAws_restXmlS3SetObjectRetentionOperation(input.S3PutObjectRetention, context).withName("S3PutObjectRetention");
         bodyNode.addChildNode(node);
     }
+    if (input.S3ReplicateObject !== undefined && input.S3ReplicateObject !== null) {
+        const node = serializeAws_restXmlS3ReplicateObjectOperation(input.S3ReplicateObject, context).withName("S3ReplicateObject");
+        bodyNode.addChildNode(node);
+    }
     return bodyNode;
 };
 const serializeAws_restXmlJobReport = (input, context) => {
@@ -5774,6 +5840,17 @@ const serializeAws_restXmlRegions = (input, context) => {
         return node.withName("Region");
     });
 };
+const serializeAws_restXmlReplicationStatusFilterList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        const node = new xml_builder_1.XmlNode("ReplicationStatus").addChildNode(new xml_builder_1.XmlText(entry));
+        return node.withName("member");
+    });
+};
 const serializeAws_restXmlS3AccessControlList = (input, context) => {
     const bodyNode = new xml_builder_1.XmlNode("S3AccessControlList");
     if (input.Owner !== undefined && input.Owner !== null) {
@@ -6007,6 +6084,66 @@ const serializeAws_restXmlS3InitiateRestoreObjectOperation = (input, context) =>
     }
     return bodyNode;
 };
+const serializeAws_restXmlS3JobManifestGenerator = (input, context) => {
+    const bodyNode = new xml_builder_1.XmlNode("S3JobManifestGenerator");
+    if (input.ExpectedBucketOwner !== undefined && input.ExpectedBucketOwner !== null) {
+        const node = new xml_builder_1.XmlNode("AccountId")
+            .addChildNode(new xml_builder_1.XmlText(input.ExpectedBucketOwner))
+            .withName("ExpectedBucketOwner");
+        bodyNode.addChildNode(node);
+    }
+    if (input.SourceBucket !== undefined && input.SourceBucket !== null) {
+        const node = new xml_builder_1.XmlNode("S3BucketArnString")
+            .addChildNode(new xml_builder_1.XmlText(input.SourceBucket))
+            .withName("SourceBucket");
+        bodyNode.addChildNode(node);
+    }
+    if (input.ManifestOutputLocation !== undefined && input.ManifestOutputLocation !== null) {
+        const node = serializeAws_restXmlS3ManifestOutputLocation(input.ManifestOutputLocation, context).withName("ManifestOutputLocation");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Filter !== undefined && input.Filter !== null) {
+        const node = serializeAws_restXmlJobManifestGeneratorFilter(input.Filter, context).withName("Filter");
+        bodyNode.addChildNode(node);
+    }
+    if (input.EnableManifestOutput !== undefined && input.EnableManifestOutput !== null) {
+        const node = new xml_builder_1.XmlNode("Boolean")
+            .addChildNode(new xml_builder_1.XmlText(String(input.EnableManifestOutput)))
+            .withName("EnableManifestOutput");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
+const serializeAws_restXmlS3ManifestOutputLocation = (input, context) => {
+    const bodyNode = new xml_builder_1.XmlNode("S3ManifestOutputLocation");
+    if (input.ExpectedManifestBucketOwner !== undefined && input.ExpectedManifestBucketOwner !== null) {
+        const node = new xml_builder_1.XmlNode("AccountId")
+            .addChildNode(new xml_builder_1.XmlText(input.ExpectedManifestBucketOwner))
+            .withName("ExpectedManifestBucketOwner");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Bucket !== undefined && input.Bucket !== null) {
+        const node = new xml_builder_1.XmlNode("S3BucketArnString").addChildNode(new xml_builder_1.XmlText(input.Bucket)).withName("Bucket");
+        bodyNode.addChildNode(node);
+    }
+    if (input.ManifestPrefix !== undefined && input.ManifestPrefix !== null) {
+        const node = new xml_builder_1.XmlNode("ManifestPrefixString")
+            .addChildNode(new xml_builder_1.XmlText(input.ManifestPrefix))
+            .withName("ManifestPrefix");
+        bodyNode.addChildNode(node);
+    }
+    if (input.ManifestEncryption !== undefined && input.ManifestEncryption !== null) {
+        const node = serializeAws_restXmlGeneratedManifestEncryption(input.ManifestEncryption, context).withName("ManifestEncryption");
+        bodyNode.addChildNode(node);
+    }
+    if (input.ManifestFormat !== undefined && input.ManifestFormat !== null) {
+        const node = new xml_builder_1.XmlNode("GeneratedManifestFormat")
+            .addChildNode(new xml_builder_1.XmlText(input.ManifestFormat))
+            .withName("ManifestFormat");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const serializeAws_restXmlS3ObjectLockLegalHold = (input, context) => {
     const bodyNode = new xml_builder_1.XmlNode("S3ObjectLockLegalHold");
     if (input.Status !== undefined && input.Status !== null) {
@@ -6103,6 +6240,10 @@ const serializeAws_restXmlS3ObjectOwner = (input, context) => {
     }
     return bodyNode;
 };
+const serializeAws_restXmlS3ReplicateObjectOperation = (input, context) => {
+    const bodyNode = new xml_builder_1.XmlNode("S3ReplicateObjectOperation");
+    return bodyNode;
+};
 const serializeAws_restXmlS3Retention = (input, context) => {
     const bodyNode = new xml_builder_1.XmlNode("S3Retention");
     if (input.RetainUntilDate !== undefined && input.RetainUntilDate !== null) {
@@ -6225,10 +6366,22 @@ const serializeAws_restXmlSSEKMS = (input, context) => {
     }
     return bodyNode;
 };
+const serializeAws_restXmlSSEKMSEncryption = (input, context) => {
+    const bodyNode = new xml_builder_1.XmlNode("SSE-KMS");
+    if (input.KeyId !== undefined && input.KeyId !== null) {
+        const node = new xml_builder_1.XmlNode("KmsKeyArnString").addChildNode(new xml_builder_1.XmlText(input.KeyId)).withName("KeyId");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const serializeAws_restXmlSSES3 = (input, context) => {
     const bodyNode = new xml_builder_1.XmlNode("SSE-S3");
     return bodyNode;
 };
+const serializeAws_restXmlSSES3Encryption = (input, context) => {
+    const bodyNode = new xml_builder_1.XmlNode("SSE-S3");
+    return bodyNode;
+};
 const serializeAws_restXmlStorageLensAwsOrg = (input, context) => {
     const bodyNode = new xml_builder_1.XmlNode("StorageLensAwsOrg");
     if (input.Arn !== undefined && input.Arn !== null) {
@@ -6636,6 +6789,19 @@ const deserializeAws_restXml_Exclude = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_restXmlGeneratedManifestEncryption = (output, context) => {
+    const contents = {
+        SSES3: undefined,
+        SSEKMS: undefined,
+    };
+    if (output["SSE-S3"] !== undefined) {
+        contents.SSES3 = deserializeAws_restXmlSSES3Encryption(output["SSE-S3"], context);
+    }
+    if (output["SSE-KMS"] !== undefined) {
+        contents.SSEKMS = deserializeAws_restXmlSSEKMSEncryption(output["SSE-KMS"], context);
+    }
+    return contents;
+};
 const deserializeAws_restXmlInclude = (output, context) => {
     const contents = {
         Buckets: undefined,
@@ -6674,6 +6840,8 @@ const deserializeAws_restXmlJobDescriptor = (output, context) => {
         RoleArn: undefined,
         SuspendedDate: undefined,
         SuspendedCause: undefined,
+        ManifestGenerator: undefined,
+        GeneratedManifestDescriptor: undefined,
     };
     if (output["JobId"] !== undefined) {
         contents.JobId = smithy_client_1.expectString(output["JobId"]);
@@ -6729,6 +6897,12 @@ const deserializeAws_restXmlJobDescriptor = (output, context) => {
     if (output["SuspendedCause"] !== undefined) {
         contents.SuspendedCause = smithy_client_1.expectString(output["SuspendedCause"]);
     }
+    if (output["ManifestGenerator"] !== undefined) {
+        contents.ManifestGenerator = deserializeAws_restXmlJobManifestGenerator(smithy_client_1.expectUnion(output["ManifestGenerator"]), context);
+    }
+    if (output["GeneratedManifestDescriptor"] !== undefined) {
+        contents.GeneratedManifestDescriptor = deserializeAws_restXmlS3GeneratedManifestDescriptor(output["GeneratedManifestDescriptor"], context);
+    }
     return contents;
 };
 const deserializeAws_restXmlJobFailure = (output, context) => {
@@ -6824,6 +6998,39 @@ const deserializeAws_restXmlJobManifestFieldList = (output, context) => {
         return smithy_client_1.expectString(entry);
     });
 };
+const deserializeAws_restXmlJobManifestGenerator = (output, context) => {
+    if (output["S3JobManifestGenerator"] !== undefined) {
+        return {
+            S3JobManifestGenerator: deserializeAws_restXmlS3JobManifestGenerator(output["S3JobManifestGenerator"], context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const deserializeAws_restXmlJobManifestGeneratorFilter = (output, context) => {
+    const contents = {
+        EligibleForReplication: undefined,
+        CreatedAfter: undefined,
+        CreatedBefore: undefined,
+        ObjectReplicationStatuses: undefined,
+    };
+    if (output["EligibleForReplication"] !== undefined) {
+        contents.EligibleForReplication = smithy_client_1.parseBoolean(output["EligibleForReplication"]);
+    }
+    if (output["CreatedAfter"] !== undefined) {
+        contents.CreatedAfter = smithy_client_1.expectNonNull(smithy_client_1.parseRfc3339DateTime(output["CreatedAfter"]));
+    }
+    if (output["CreatedBefore"] !== undefined) {
+        contents.CreatedBefore = smithy_client_1.expectNonNull(smithy_client_1.parseRfc3339DateTime(output["CreatedBefore"]));
+    }
+    if (output.ObjectReplicationStatuses === "") {
+        contents.ObjectReplicationStatuses = [];
+    }
+    if (output["ObjectReplicationStatuses"] !== undefined &&
+        output["ObjectReplicationStatuses"]["member"] !== undefined) {
+        contents.ObjectReplicationStatuses = deserializeAws_restXmlReplicationStatusFilterList(smithy_client_1.getArrayIfSingleItem(output["ObjectReplicationStatuses"]["member"]), context);
+    }
+    return contents;
+};
 const deserializeAws_restXmlJobManifestLocation = (output, context) => {
     const contents = {
         ObjectArn: undefined,
@@ -6867,6 +7074,7 @@ const deserializeAws_restXmlJobOperation = (output, context) => {
         S3InitiateRestoreObject: undefined,
         S3PutObjectLegalHold: undefined,
         S3PutObjectRetention: undefined,
+        S3ReplicateObject: undefined,
     };
     if (output["LambdaInvoke"] !== undefined) {
         contents.LambdaInvoke = deserializeAws_restXmlLambdaInvokeOperation(output["LambdaInvoke"], context);
@@ -6892,6 +7100,9 @@ const deserializeAws_restXmlJobOperation = (output, context) => {
     if (output["S3PutObjectRetention"] !== undefined) {
         contents.S3PutObjectRetention = deserializeAws_restXmlS3SetObjectRetentionOperation(output["S3PutObjectRetention"], context);
     }
+    if (output["S3ReplicateObject"] !== undefined) {
+        contents.S3ReplicateObject = deserializeAws_restXmlS3ReplicateObjectOperation(output["S3ReplicateObject"], context);
+    }
     return contents;
 };
 const deserializeAws_restXmlJobProgressSummary = (output, context) => {
@@ -6899,6 +7110,7 @@ const deserializeAws_restXmlJobProgressSummary = (output, context) => {
         TotalNumberOfTasks: undefined,
         NumberOfTasksSucceeded: undefined,
         NumberOfTasksFailed: undefined,
+        Timers: undefined,
     };
     if (output["TotalNumberOfTasks"] !== undefined) {
         contents.TotalNumberOfTasks = smithy_client_1.strictParseLong(output["TotalNumberOfTasks"]);
@@ -6909,6 +7121,9 @@ const deserializeAws_restXmlJobProgressSummary = (output, context) => {
     if (output["NumberOfTasksFailed"] !== undefined) {
         contents.NumberOfTasksFailed = smithy_client_1.strictParseLong(output["NumberOfTasksFailed"]);
     }
+    if (output["Timers"] !== undefined) {
+        contents.Timers = deserializeAws_restXmlJobTimers(output["Timers"], context);
+    }
     return contents;
 };
 const deserializeAws_restXmlJobReport = (output, context) => {
@@ -6936,6 +7151,15 @@ const deserializeAws_restXmlJobReport = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_restXmlJobTimers = (output, context) => {
+    const contents = {
+        ElapsedTimeInActiveSeconds: undefined,
+    };
+    if (output["ElapsedTimeInActiveSeconds"] !== undefined) {
+        contents.ElapsedTimeInActiveSeconds = smithy_client_1.strictParseLong(output["ElapsedTimeInActiveSeconds"]);
+    }
+    return contents;
+};
 const deserializeAws_restXmlLambdaInvokeOperation = (output, context) => {
     const contents = {
         FunctionArn: undefined,
@@ -7458,6 +7682,16 @@ const deserializeAws_restXmlRegions = (output, context) => {
         return smithy_client_1.expectString(entry);
     });
 };
+const deserializeAws_restXmlReplicationStatusFilterList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
 const deserializeAws_restXmlS3AccessControlList = (output, context) => {
     const contents = {
         Owner: undefined,
@@ -7599,6 +7833,19 @@ const deserializeAws_restXmlS3DeleteObjectTaggingOperation = (output, context) =
     const contents = {};
     return contents;
 };
+const deserializeAws_restXmlS3GeneratedManifestDescriptor = (output, context) => {
+    const contents = {
+        Format: undefined,
+        Location: undefined,
+    };
+    if (output["Format"] !== undefined) {
+        contents.Format = smithy_client_1.expectString(output["Format"]);
+    }
+    if (output["Location"] !== undefined) {
+        contents.Location = deserializeAws_restXmlJobManifestLocation(output["Location"], context);
+    }
+    return contents;
+};
 const deserializeAws_restXmlS3Grant = (output, context) => {
     const contents = {
         Grantee: undefined,
@@ -7652,6 +7899,56 @@ const deserializeAws_restXmlS3InitiateRestoreObjectOperation = (output, context)
     }
     return contents;
 };
+const deserializeAws_restXmlS3JobManifestGenerator = (output, context) => {
+    const contents = {
+        ExpectedBucketOwner: undefined,
+        SourceBucket: undefined,
+        ManifestOutputLocation: undefined,
+        Filter: undefined,
+        EnableManifestOutput: undefined,
+    };
+    if (output["ExpectedBucketOwner"] !== undefined) {
+        contents.ExpectedBucketOwner = smithy_client_1.expectString(output["ExpectedBucketOwner"]);
+    }
+    if (output["SourceBucket"] !== undefined) {
+        contents.SourceBucket = smithy_client_1.expectString(output["SourceBucket"]);
+    }
+    if (output["ManifestOutputLocation"] !== undefined) {
+        contents.ManifestOutputLocation = deserializeAws_restXmlS3ManifestOutputLocation(output["ManifestOutputLocation"], context);
+    }
+    if (output["Filter"] !== undefined) {
+        contents.Filter = deserializeAws_restXmlJobManifestGeneratorFilter(output["Filter"], context);
+    }
+    if (output["EnableManifestOutput"] !== undefined) {
+        contents.EnableManifestOutput = smithy_client_1.parseBoolean(output["EnableManifestOutput"]);
+    }
+    return contents;
+};
+const deserializeAws_restXmlS3ManifestOutputLocation = (output, context) => {
+    const contents = {
+        ExpectedManifestBucketOwner: undefined,
+        Bucket: undefined,
+        ManifestPrefix: undefined,
+        ManifestEncryption: undefined,
+        ManifestFormat: undefined,
+    };
+    if (output["ExpectedManifestBucketOwner"] !== undefined) {
+        contents.ExpectedManifestBucketOwner = smithy_client_1.expectString(output["ExpectedManifestBucketOwner"]);
+    }
+    if (output["Bucket"] !== undefined) {
+        contents.Bucket = smithy_client_1.expectString(output["Bucket"]);
+    }
+    if (output["ManifestPrefix"] !== undefined) {
+        contents.ManifestPrefix = smithy_client_1.expectString(output["ManifestPrefix"]);
+    }
+    if (output["ManifestEncryption"] !== undefined) {
+        contents.ManifestEncryption = deserializeAws_restXmlGeneratedManifestEncryption(output["ManifestEncryption"], context);
+    }
+    if (output["ManifestFormat"] !== undefined) {
+        contents.ManifestFormat = smithy_client_1.expectString(output["ManifestFormat"]);
+    }
+    return contents;
+};
 const deserializeAws_restXmlS3ObjectLockLegalHold = (output, context) => {
     const contents = {
         Status: undefined,
@@ -7726,6 +8023,10 @@ const deserializeAws_restXmlS3ObjectOwner = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_restXmlS3ReplicateObjectOperation = (output, context) => {
+    const contents = {};
+    return contents;
+};
 const deserializeAws_restXmlS3Retention = (output, context) => {
     const contents = {
         RetainUntilDate: undefined,
@@ -7842,10 +8143,23 @@ const deserializeAws_restXmlSSEKMS = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_restXmlSSEKMSEncryption = (output, context) => {
+    const contents = {
+        KeyId: undefined,
+    };
+    if (output["KeyId"] !== undefined) {
+        contents.KeyId = smithy_client_1.expectString(output["KeyId"]);
+    }
+    return contents;
+};
 const deserializeAws_restXmlSSES3 = (output, context) => {
     const contents = {};
     return contents;
 };
+const deserializeAws_restXmlSSES3Encryption = (output, context) => {
+    const contents = {};
+    return contents;
+};
 const deserializeAws_restXmlStorageLensAwsOrg = (output, context) => {
     const contents = {
         Arn: undefined,

package/dist-es/models/models_0.js

@@ -184,6 +184,56 @@ export var JobManifest;
 (function (JobManifest) {
     JobManifest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(JobManifest || (JobManifest = {}));
+export var ReplicationStatus;
+(function (ReplicationStatus) {
+    ReplicationStatus["COMPLETED"] = "COMPLETED";
+    ReplicationStatus["FAILED"] = "FAILED";
+    ReplicationStatus["NONE"] = "NONE";
+    ReplicationStatus["REPLICA"] = "REPLICA";
+})(ReplicationStatus || (ReplicationStatus = {}));
+export var JobManifestGeneratorFilter;
+(function (JobManifestGeneratorFilter) {
+    JobManifestGeneratorFilter.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(JobManifestGeneratorFilter || (JobManifestGeneratorFilter = {}));
+export var SSEKMSEncryption;
+(function (SSEKMSEncryption) {
+    SSEKMSEncryption.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(SSEKMSEncryption || (SSEKMSEncryption = {}));
+export var SSES3Encryption;
+(function (SSES3Encryption) {
+    SSES3Encryption.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(SSES3Encryption || (SSES3Encryption = {}));
+export var GeneratedManifestEncryption;
+(function (GeneratedManifestEncryption) {
+    GeneratedManifestEncryption.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GeneratedManifestEncryption || (GeneratedManifestEncryption = {}));
+export var GeneratedManifestFormat;
+(function (GeneratedManifestFormat) {
+    GeneratedManifestFormat["S3InventoryReport_CSV_20211130"] = "S3InventoryReport_CSV_20211130";
+})(GeneratedManifestFormat || (GeneratedManifestFormat = {}));
+export var S3ManifestOutputLocation;
+(function (S3ManifestOutputLocation) {
+    S3ManifestOutputLocation.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(S3ManifestOutputLocation || (S3ManifestOutputLocation = {}));
+export var S3JobManifestGenerator;
+(function (S3JobManifestGenerator) {
+    S3JobManifestGenerator.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(S3JobManifestGenerator || (S3JobManifestGenerator = {}));
+export var JobManifestGenerator;
+(function (JobManifestGenerator) {
+    JobManifestGenerator.visit = function (value, visitor) {
+        if (value.S3JobManifestGenerator !== undefined)
+            return visitor.S3JobManifestGenerator(value.S3JobManifestGenerator);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+    JobManifestGenerator.filterSensitiveLog = function (obj) {
+        var _a;
+        if (obj.S3JobManifestGenerator !== undefined)
+            return { S3JobManifestGenerator: S3JobManifestGenerator.filterSensitiveLog(obj.S3JobManifestGenerator) };
+        if (obj.$unknown !== undefined)
+            return _a = {}, _a[obj.$unknown[0]] = "UNKNOWN", _a;
+    };
+})(JobManifestGenerator || (JobManifestGenerator = {}));
 export var LambdaInvokeOperation;
 (function (LambdaInvokeOperation) {
     LambdaInvokeOperation.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -281,6 +331,7 @@ export var S3StorageClass;
 (function (S3StorageClass) {
     S3StorageClass["DEEP_ARCHIVE"] = "DEEP_ARCHIVE";
     S3StorageClass["GLACIER"] = "GLACIER";
+    S3StorageClass["GLACIER_IR"] = "GLACIER_IR";
     S3StorageClass["INTELLIGENT_TIERING"] = "INTELLIGENT_TIERING";
     S3StorageClass["ONEZONE_IA"] = "ONEZONE_IA";
     S3StorageClass["STANDARD"] = "STANDARD";
@@ -315,6 +366,10 @@ export var S3SetObjectTaggingOperation;
 (function (S3SetObjectTaggingOperation) {
     S3SetObjectTaggingOperation.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(S3SetObjectTaggingOperation || (S3SetObjectTaggingOperation = {}));
+export var S3ReplicateObjectOperation;
+(function (S3ReplicateObjectOperation) {
+    S3ReplicateObjectOperation.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(S3ReplicateObjectOperation || (S3ReplicateObjectOperation = {}));
 export var JobOperation;
 (function (JobOperation) {
     JobOperation.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -334,7 +389,7 @@ export var JobReport;
 })(JobReport || (JobReport = {}));
 export var CreateJobRequest;
 (function (CreateJobRequest) {
-    CreateJobRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+    CreateJobRequest.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.ManifestGenerator && { ManifestGenerator: JobManifestGenerator.filterSensitiveLog(obj.ManifestGenerator) }))); };
 })(CreateJobRequest || (CreateJobRequest = {}));
 export var CreateJobResult;
 (function (CreateJobResult) {
@@ -420,6 +475,14 @@ export var JobFailure;
 (function (JobFailure) {
     JobFailure.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(JobFailure || (JobFailure = {}));
+export var S3GeneratedManifestDescriptor;
+(function (S3GeneratedManifestDescriptor) {
+    S3GeneratedManifestDescriptor.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(S3GeneratedManifestDescriptor || (S3GeneratedManifestDescriptor = {}));
+export var JobTimers;
+(function (JobTimers) {
+    JobTimers.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(JobTimers || (JobTimers = {}));
 export var JobProgressSummary;
 (function (JobProgressSummary) {
     JobProgressSummary.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -442,11 +505,11 @@ export var JobStatus;
 })(JobStatus || (JobStatus = {}));
 export var JobDescriptor;
 (function (JobDescriptor) {
-    JobDescriptor.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+    JobDescriptor.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.ManifestGenerator && { ManifestGenerator: JobManifestGenerator.filterSensitiveLog(obj.ManifestGenerator) }))); };
 })(JobDescriptor || (JobDescriptor = {}));
 export var DescribeJobResult;
 (function (DescribeJobResult) {
-    DescribeJobResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+    DescribeJobResult.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.Job && { Job: JobDescriptor.filterSensitiveLog(obj.Job) }))); };
 })(DescribeJobResult || (DescribeJobResult = {}));
 export var DescribeMultiRegionAccessPointOperationRequest;
 (function (DescribeMultiRegionAccessPointOperationRequest) {
@@ -739,6 +802,7 @@ export var OperationName;
     OperationName["S3PutObjectLegalHold"] = "S3PutObjectLegalHold";
     OperationName["S3PutObjectRetention"] = "S3PutObjectRetention";
     OperationName["S3PutObjectTagging"] = "S3PutObjectTagging";
+    OperationName["S3ReplicateObject"] = "S3ReplicateObject";
 })(OperationName || (OperationName = {}));
 export var JobListDescriptor;
 (function (JobListDescriptor) {