@aws-sdk/client-s3-control 3.451.0 → 3.454.0

package/dist-es/protocols/Aws_restXml.js

@@ -259,6 +259,51 @@ export const se_CreateMultiRegionAccessPointCommand = async (input, context) =>
         body,
     });
 };
+export const se_CreateStorageLensGroupCommand = 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,
+    });
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20180820/storagelensgroup";
+    let body;
+    body = '<?xml version="1.0" encoding="UTF-8"?>';
+    const bodyNode = new __XmlNode("CreateStorageLensGroupRequest");
+    bodyNode.addAttribute("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
+    if (input.StorageLensGroup !== undefined) {
+        const node = se_StorageLensGroup(input.StorageLensGroup, context).withName("StorageLensGroup");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Tags !== undefined) {
+        const nodes = se_TagList(input.Tags, context);
+        const containerNode = new __XmlNode("Tags");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    body += bodyNode.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: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_DeleteAccessPointCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
@@ -683,6 +728,35 @@ export const se_DeleteStorageLensConfigurationTaggingCommand = async (input, con
         body,
     });
 };
+export const se_DeleteStorageLensGroupCommand = 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/storagelensgroup/{Name}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", 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 se_DescribeJobCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
@@ -1358,6 +1432,35 @@ export const se_GetStorageLensConfigurationTaggingCommand = async (input, contex
         body,
     });
 };
+export const se_GetStorageLensGroupCommand = 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/storagelensgroup/{Name}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", 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 se_ListAccessPointsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
@@ -1558,6 +1661,67 @@ export const se_ListStorageLensConfigurationsCommand = async (input, context) =>
         body,
     });
 };
+export const se_ListStorageLensGroupsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = map({}, isSerializableHeaderValue, {
+        "x-amz-account-id": input.AccountId,
+    });
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20180820/storagelensgroup";
+    const query = map({
+        nextToken: [, input.NextToken],
+    });
+    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,
+        query,
+        body,
+    });
+};
+export const se_ListTagsForResourceCommand = 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/tags/{ResourceArn+}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn+}", true);
+    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 se_PutAccessPointConfigurationForObjectLambdaCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
@@ -2134,6 +2298,84 @@ export const se_SubmitMultiRegionAccessPointRoutesCommand = async (input, contex
         body,
     });
 };
+export const se_TagResourceCommand = 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/tags/{ResourceArn+}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn+}", true);
+    let body;
+    body = '<?xml version="1.0" encoding="UTF-8"?>';
+    const bodyNode = new __XmlNode("TagResourceRequest");
+    bodyNode.addAttribute("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
+    if (input.Tags !== undefined) {
+        const nodes = se_TagList(input.Tags, context);
+        const containerNode = new __XmlNode("Tags");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    body += bodyNode.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: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_UntagResourceCommand = 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/tags/{ResourceArn+}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn+}", true);
+    const query = map({
+        tagKeys: [
+            __expectNonNull(input.TagKeys, `TagKeys`) != null,
+            () => (input.TagKeys || []).map((_entry) => _entry),
+        ],
+    });
+    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,
+        query,
+        body,
+    });
+};
 export const se_UpdateJobPriorityCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
@@ -2201,6 +2443,44 @@ export const se_UpdateJobStatusCommand = async (input, context) => {
         body,
     });
 };
+export const se_UpdateStorageLensGroupCommand = 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/storagelensgroup/{Name}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
+    let body;
+    body = '<?xml version="1.0" encoding="UTF-8"?>';
+    const bodyNode = new __XmlNode("UpdateStorageLensGroupRequest");
+    bodyNode.addAttribute("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
+    if (input.StorageLensGroup !== undefined) {
+        const node = se_StorageLensGroup(input.StorageLensGroup, context).withName("StorageLensGroup");
+        bodyNode.addChildNode(node);
+    }
+    body += bodyNode.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 de_CreateAccessPointCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CreateAccessPointCommandError(output, context);
@@ -2362,6 +2642,29 @@ const de_CreateMultiRegionAccessPointCommandError = async (output, context) => {
         errorCode,
     });
 };
+export const de_CreateStorageLensGroupCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return de_CreateStorageLensGroupCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_CreateStorageLensGroupCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode,
+    });
+};
 export const de_DeleteAccessPointCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_DeleteAccessPointCommandError(output, context);
@@ -2699,6 +3002,29 @@ const de_DeleteStorageLensConfigurationTaggingCommandError = async (output, cont
         errorCode,
     });
 };
+export const de_DeleteStorageLensGroupCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return de_DeleteStorageLensGroupCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_DeleteStorageLensGroupCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode,
+    });
+};
 export const de_DescribeJobCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_DescribeJobCommandError(output, context);
@@ -3392,6 +3718,30 @@ const de_GetStorageLensConfigurationTaggingCommandError = async (output, context
         errorCode,
     });
 };
+export const de_GetStorageLensGroupCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetStorageLensGroupCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectObject(await parseBody(output.body, context));
+    contents.StorageLensGroup = de_StorageLensGroup(data, context);
+    return contents;
+};
+const de_GetStorageLensGroupCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode,
+    });
+};
 export const de_ListAccessPointsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_ListAccessPointsCommandError(output, context);
@@ -3597,6 +3947,67 @@ const de_ListStorageLensConfigurationsCommandError = async (output, context) =>
         errorCode,
     });
 };
+export const de_ListStorageLensGroupsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListStorageLensGroupsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data["NextToken"] !== undefined) {
+        contents.NextToken = __expectString(data["NextToken"]);
+    }
+    if (data.StorageLensGroupList === "") {
+        contents.StorageLensGroupList = [];
+    }
+    else if (data["StorageLensGroupList"] !== undefined) {
+        contents.StorageLensGroupList = de_StorageLensGroupList(__getArrayIfSingleItem(data["StorageLensGroupList"]), context);
+    }
+    return contents;
+};
+const de_ListStorageLensGroupsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode,
+    });
+};
+export const de_ListTagsForResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListTagsForResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.Tags === "") {
+        contents.Tags = [];
+    }
+    else if (data["Tags"] !== undefined && data["Tags"]["Tag"] !== undefined) {
+        contents.Tags = de_TagList(__getArrayIfSingleItem(data["Tags"]["Tag"]), context);
+    }
+    return contents;
+};
+const de_ListTagsForResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode,
+    });
+};
 export const de_PutAccessPointConfigurationForObjectLambdaCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_PutAccessPointConfigurationForObjectLambdaCommandError(output, context);
@@ -3937,6 +4348,52 @@ const de_SubmitMultiRegionAccessPointRoutesCommandError = async (output, context
         errorCode,
     });
 };
+export const de_TagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return de_TagResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_TagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode,
+    });
+};
+export const de_UntagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return de_UntagResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_UntagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode,
+    });
+};
 export const de_UpdateJobPriorityCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_UpdateJobPriorityCommandError(output, context);
@@ -4031,6 +4488,29 @@ const de_UpdateJobStatusCommandError = async (output, context) => {
             });
     }
 };
+export const de_UpdateStorageLensGroupCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return de_UpdateStorageLensGroupCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_UpdateStorageLensGroupCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode,
+    });
+};
 const throwDefaultError = withBaseException(__BaseException);
 const de_BadRequestExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
@@ -4208,6 +4688,10 @@ const se_AccountLevel = (input, context) => {
         const node = se_DetailedStatusCodesMetrics(input.DetailedStatusCodesMetrics, context).withName("DetailedStatusCodesMetrics");
         bodyNode.addChildNode(node);
     }
+    if (input.StorageLensGroupLevel != null) {
+        const node = se_StorageLensGroupLevel(input.StorageLensGroupLevel, context).withName("StorageLensGroupLevel");
+        bodyNode.addChildNode(node);
+    }
     return bodyNode;
 };
 const se_ActivityMetrics = (input, context) => {
@@ -4744,6 +5228,54 @@ const se_LifecycleRules = (input, context) => {
         return node.withName("Rule");
     });
 };
+const se_MatchAnyPrefix = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        const node = __XmlNode.of("Prefix", entry);
+        return node.withName("Prefix");
+    });
+};
+const se_MatchAnySuffix = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        const node = __XmlNode.of("Suffix", entry);
+        return node.withName("Suffix");
+    });
+};
+const se_MatchAnyTag = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        const node = se_S3Tag(entry, context);
+        return node.withName("Tag");
+    });
+};
+const se_MatchObjectAge = (input, context) => {
+    const bodyNode = new __XmlNode("MatchObjectAge");
+    if (input.DaysGreaterThan != null) {
+        const node = __XmlNode.of("ObjectAgeValue", String(input.DaysGreaterThan)).withName("DaysGreaterThan");
+        bodyNode.addChildNode(node);
+    }
+    if (input.DaysLessThan != null) {
+        const node = __XmlNode.of("ObjectAgeValue", String(input.DaysLessThan)).withName("DaysLessThan");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
+const se_MatchObjectSize = (input, context) => {
+    const bodyNode = new __XmlNode("MatchObjectSize");
+    if (input.BytesGreaterThan != null) {
+        const node = __XmlNode.of("ObjectSizeValue", String(input.BytesGreaterThan)).withName("BytesGreaterThan");
+        bodyNode.addChildNode(node);
+    }
+    if (input.BytesLessThan != null) {
+        const node = __XmlNode.of("ObjectSizeValue", String(input.BytesLessThan)).withName("BytesLessThan");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const se_Metrics = (input, context) => {
     const bodyNode = new __XmlNode("Metrics");
     if (input.Status != null) {
@@ -5665,6 +6197,182 @@ const se_StorageLensDataExportEncryption = (input, context) => {
     }
     return bodyNode;
 };
+const se_StorageLensGroup = (input, context) => {
+    const bodyNode = new __XmlNode("StorageLensGroup");
+    if (input.Name != null) {
+        const node = __XmlNode.of("StorageLensGroupName", input.Name).withName("Name");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Filter != null) {
+        const node = se_StorageLensGroupFilter(input.Filter, context).withName("Filter");
+        bodyNode.addChildNode(node);
+    }
+    if (input.StorageLensGroupArn != null) {
+        const node = __XmlNode.of("StorageLensGroupArn", input.StorageLensGroupArn).withName("StorageLensGroupArn");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
+const se_StorageLensGroupAndOperator = (input, context) => {
+    const bodyNode = new __XmlNode("StorageLensGroupAndOperator");
+    if (input.MatchAnyPrefix != null) {
+        const nodes = se_MatchAnyPrefix(input.MatchAnyPrefix, context);
+        const containerNode = new __XmlNode("MatchAnyPrefix");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    if (input.MatchAnySuffix != null) {
+        const nodes = se_MatchAnySuffix(input.MatchAnySuffix, context);
+        const containerNode = new __XmlNode("MatchAnySuffix");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    if (input.MatchAnyTag != null) {
+        const nodes = se_MatchAnyTag(input.MatchAnyTag, context);
+        const containerNode = new __XmlNode("MatchAnyTag");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    if (input.MatchObjectAge != null) {
+        const node = se_MatchObjectAge(input.MatchObjectAge, context).withName("MatchObjectAge");
+        bodyNode.addChildNode(node);
+    }
+    if (input.MatchObjectSize != null) {
+        const node = se_MatchObjectSize(input.MatchObjectSize, context).withName("MatchObjectSize");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
+const se_StorageLensGroupFilter = (input, context) => {
+    const bodyNode = new __XmlNode("StorageLensGroupFilter");
+    if (input.MatchAnyPrefix != null) {
+        const nodes = se_MatchAnyPrefix(input.MatchAnyPrefix, context);
+        const containerNode = new __XmlNode("MatchAnyPrefix");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    if (input.MatchAnySuffix != null) {
+        const nodes = se_MatchAnySuffix(input.MatchAnySuffix, context);
+        const containerNode = new __XmlNode("MatchAnySuffix");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    if (input.MatchAnyTag != null) {
+        const nodes = se_MatchAnyTag(input.MatchAnyTag, context);
+        const containerNode = new __XmlNode("MatchAnyTag");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    if (input.MatchObjectAge != null) {
+        const node = se_MatchObjectAge(input.MatchObjectAge, context).withName("MatchObjectAge");
+        bodyNode.addChildNode(node);
+    }
+    if (input.MatchObjectSize != null) {
+        const node = se_MatchObjectSize(input.MatchObjectSize, context).withName("MatchObjectSize");
+        bodyNode.addChildNode(node);
+    }
+    if (input.And != null) {
+        const node = se_StorageLensGroupAndOperator(input.And, context).withName("And");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Or != null) {
+        const node = se_StorageLensGroupOrOperator(input.Or, context).withName("Or");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
+const se_StorageLensGroupLevel = (input, context) => {
+    const bodyNode = new __XmlNode("StorageLensGroupLevel");
+    if (input.SelectionCriteria != null) {
+        const node = se_StorageLensGroupLevelSelectionCriteria(input.SelectionCriteria, context).withName("SelectionCriteria");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
+const se_StorageLensGroupLevelExclude = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        const node = __XmlNode.of("StorageLensGroupArn", entry);
+        return node.withName("Arn");
+    });
+};
+const se_StorageLensGroupLevelInclude = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        const node = __XmlNode.of("StorageLensGroupArn", entry);
+        return node.withName("Arn");
+    });
+};
+const se_StorageLensGroupLevelSelectionCriteria = (input, context) => {
+    const bodyNode = new __XmlNode("StorageLensGroupLevelSelectionCriteria");
+    if (input.Include != null) {
+        const nodes = se_StorageLensGroupLevelInclude(input.Include, context);
+        const containerNode = new __XmlNode("Include");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    if (input.Exclude != null) {
+        const nodes = se_StorageLensGroupLevelExclude(input.Exclude, context);
+        const containerNode = new __XmlNode("Exclude");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    return bodyNode;
+};
+const se_StorageLensGroupOrOperator = (input, context) => {
+    const bodyNode = new __XmlNode("StorageLensGroupOrOperator");
+    if (input.MatchAnyPrefix != null) {
+        const nodes = se_MatchAnyPrefix(input.MatchAnyPrefix, context);
+        const containerNode = new __XmlNode("MatchAnyPrefix");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    if (input.MatchAnySuffix != null) {
+        const nodes = se_MatchAnySuffix(input.MatchAnySuffix, context);
+        const containerNode = new __XmlNode("MatchAnySuffix");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    if (input.MatchAnyTag != null) {
+        const nodes = se_MatchAnyTag(input.MatchAnyTag, context);
+        const containerNode = new __XmlNode("MatchAnyTag");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    if (input.MatchObjectAge != null) {
+        const node = se_MatchObjectAge(input.MatchObjectAge, context).withName("MatchObjectAge");
+        bodyNode.addChildNode(node);
+    }
+    if (input.MatchObjectSize != null) {
+        const node = se_MatchObjectSize(input.MatchObjectSize, context).withName("MatchObjectSize");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const se_StorageLensTag = (input, context) => {
     const bodyNode = new __XmlNode("StorageLensTag");
     if (input.Key != null) {
@@ -5685,6 +6393,18 @@ const se_StorageLensTags = (input, context) => {
         return node.withName("Tag");
     });
 };
+const se_Tag = (input, context) => {
+    const bodyNode = new __XmlNode("Tag");
+    if (input.Key != null) {
+        const node = __XmlNode.of("TagKeyString", input.Key).withName("Key");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Value != null) {
+        const node = __XmlNode.of("TagValueString", input.Value).withName("Value");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const se_Tagging = (input, context) => {
     const bodyNode = new __XmlNode("Tagging");
     if (input.TagSet != null) {
@@ -5697,6 +6417,14 @@ const se_Tagging = (input, context) => {
     }
     return bodyNode;
 };
+const se_TagList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        const node = se_Tag(entry, context);
+        return node.withName("Tag");
+    });
+};
 const se_Transition = (input, context) => {
     const bodyNode = new __XmlNode("Transition");
     if (input.Date != null) {
@@ -5804,6 +6532,9 @@ const de_AccountLevel = (output, context) => {
     if (output["DetailedStatusCodesMetrics"] !== undefined) {
         contents.DetailedStatusCodesMetrics = de_DetailedStatusCodesMetrics(output["DetailedStatusCodesMetrics"], context);
     }
+    if (output["StorageLensGroupLevel"] !== undefined) {
+        contents.StorageLensGroupLevel = de_StorageLensGroupLevel(output["StorageLensGroupLevel"], context);
+    }
     return contents;
 };
 const de_ActivityMetrics = (output, context) => {
@@ -6443,6 +7174,60 @@ const de_ListStorageLensConfigurationEntry = (output, context) => {
     }
     return contents;
 };
+const de_ListStorageLensGroupEntry = (output, context) => {
+    const contents = {};
+    if (output["Name"] !== undefined) {
+        contents.Name = __expectString(output["Name"]);
+    }
+    if (output["StorageLensGroupArn"] !== undefined) {
+        contents.StorageLensGroupArn = __expectString(output["StorageLensGroupArn"]);
+    }
+    if (output["HomeRegion"] !== undefined) {
+        contents.HomeRegion = __expectString(output["HomeRegion"]);
+    }
+    return contents;
+};
+const de_MatchAnyPrefix = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return __expectString(entry);
+    });
+};
+const de_MatchAnySuffix = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return __expectString(entry);
+    });
+};
+const de_MatchAnyTag = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_S3Tag(entry, context);
+    });
+};
+const de_MatchObjectAge = (output, context) => {
+    const contents = {};
+    if (output["DaysGreaterThan"] !== undefined) {
+        contents.DaysGreaterThan = __strictParseInt32(output["DaysGreaterThan"]);
+    }
+    if (output["DaysLessThan"] !== undefined) {
+        contents.DaysLessThan = __strictParseInt32(output["DaysLessThan"]);
+    }
+    return contents;
+};
+const de_MatchObjectSize = (output, context) => {
+    const contents = {};
+    if (output["BytesGreaterThan"] !== undefined) {
+        contents.BytesGreaterThan = __strictParseLong(output["BytesGreaterThan"]);
+    }
+    if (output["BytesLessThan"] !== undefined) {
+        contents.BytesLessThan = __strictParseLong(output["BytesLessThan"]);
+    }
+    return contents;
+};
 const de_Metrics = (output, context) => {
     const contents = {};
     if (output["Status"] !== undefined) {
@@ -7350,6 +8135,153 @@ const de_StorageLensDataExportEncryption = (output, context) => {
     }
     return contents;
 };
+const de_StorageLensGroup = (output, context) => {
+    const contents = {};
+    if (output["Name"] !== undefined) {
+        contents.Name = __expectString(output["Name"]);
+    }
+    if (output["Filter"] !== undefined) {
+        contents.Filter = de_StorageLensGroupFilter(output["Filter"], context);
+    }
+    if (output["StorageLensGroupArn"] !== undefined) {
+        contents.StorageLensGroupArn = __expectString(output["StorageLensGroupArn"]);
+    }
+    return contents;
+};
+const de_StorageLensGroupAndOperator = (output, context) => {
+    const contents = {};
+    if (output.MatchAnyPrefix === "") {
+        contents.MatchAnyPrefix = [];
+    }
+    else if (output["MatchAnyPrefix"] !== undefined && output["MatchAnyPrefix"]["Prefix"] !== undefined) {
+        contents.MatchAnyPrefix = de_MatchAnyPrefix(__getArrayIfSingleItem(output["MatchAnyPrefix"]["Prefix"]), context);
+    }
+    if (output.MatchAnySuffix === "") {
+        contents.MatchAnySuffix = [];
+    }
+    else if (output["MatchAnySuffix"] !== undefined && output["MatchAnySuffix"]["Suffix"] !== undefined) {
+        contents.MatchAnySuffix = de_MatchAnySuffix(__getArrayIfSingleItem(output["MatchAnySuffix"]["Suffix"]), context);
+    }
+    if (output.MatchAnyTag === "") {
+        contents.MatchAnyTag = [];
+    }
+    else if (output["MatchAnyTag"] !== undefined && output["MatchAnyTag"]["Tag"] !== undefined) {
+        contents.MatchAnyTag = de_MatchAnyTag(__getArrayIfSingleItem(output["MatchAnyTag"]["Tag"]), context);
+    }
+    if (output["MatchObjectAge"] !== undefined) {
+        contents.MatchObjectAge = de_MatchObjectAge(output["MatchObjectAge"], context);
+    }
+    if (output["MatchObjectSize"] !== undefined) {
+        contents.MatchObjectSize = de_MatchObjectSize(output["MatchObjectSize"], context);
+    }
+    return contents;
+};
+const de_StorageLensGroupFilter = (output, context) => {
+    const contents = {};
+    if (output.MatchAnyPrefix === "") {
+        contents.MatchAnyPrefix = [];
+    }
+    else if (output["MatchAnyPrefix"] !== undefined && output["MatchAnyPrefix"]["Prefix"] !== undefined) {
+        contents.MatchAnyPrefix = de_MatchAnyPrefix(__getArrayIfSingleItem(output["MatchAnyPrefix"]["Prefix"]), context);
+    }
+    if (output.MatchAnySuffix === "") {
+        contents.MatchAnySuffix = [];
+    }
+    else if (output["MatchAnySuffix"] !== undefined && output["MatchAnySuffix"]["Suffix"] !== undefined) {
+        contents.MatchAnySuffix = de_MatchAnySuffix(__getArrayIfSingleItem(output["MatchAnySuffix"]["Suffix"]), context);
+    }
+    if (output.MatchAnyTag === "") {
+        contents.MatchAnyTag = [];
+    }
+    else if (output["MatchAnyTag"] !== undefined && output["MatchAnyTag"]["Tag"] !== undefined) {
+        contents.MatchAnyTag = de_MatchAnyTag(__getArrayIfSingleItem(output["MatchAnyTag"]["Tag"]), context);
+    }
+    if (output["MatchObjectAge"] !== undefined) {
+        contents.MatchObjectAge = de_MatchObjectAge(output["MatchObjectAge"], context);
+    }
+    if (output["MatchObjectSize"] !== undefined) {
+        contents.MatchObjectSize = de_MatchObjectSize(output["MatchObjectSize"], context);
+    }
+    if (output["And"] !== undefined) {
+        contents.And = de_StorageLensGroupAndOperator(output["And"], context);
+    }
+    if (output["Or"] !== undefined) {
+        contents.Or = de_StorageLensGroupOrOperator(output["Or"], context);
+    }
+    return contents;
+};
+const de_StorageLensGroupLevel = (output, context) => {
+    const contents = {};
+    if (output["SelectionCriteria"] !== undefined) {
+        contents.SelectionCriteria = de_StorageLensGroupLevelSelectionCriteria(output["SelectionCriteria"], context);
+    }
+    return contents;
+};
+const de_StorageLensGroupLevelExclude = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return __expectString(entry);
+    });
+};
+const de_StorageLensGroupLevelInclude = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return __expectString(entry);
+    });
+};
+const de_StorageLensGroupLevelSelectionCriteria = (output, context) => {
+    const contents = {};
+    if (output.Include === "") {
+        contents.Include = [];
+    }
+    else if (output["Include"] !== undefined && output["Include"]["Arn"] !== undefined) {
+        contents.Include = de_StorageLensGroupLevelInclude(__getArrayIfSingleItem(output["Include"]["Arn"]), context);
+    }
+    if (output.Exclude === "") {
+        contents.Exclude = [];
+    }
+    else if (output["Exclude"] !== undefined && output["Exclude"]["Arn"] !== undefined) {
+        contents.Exclude = de_StorageLensGroupLevelExclude(__getArrayIfSingleItem(output["Exclude"]["Arn"]), context);
+    }
+    return contents;
+};
+const de_StorageLensGroupList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ListStorageLensGroupEntry(entry, context);
+    });
+};
+const de_StorageLensGroupOrOperator = (output, context) => {
+    const contents = {};
+    if (output.MatchAnyPrefix === "") {
+        contents.MatchAnyPrefix = [];
+    }
+    else if (output["MatchAnyPrefix"] !== undefined && output["MatchAnyPrefix"]["Prefix"] !== undefined) {
+        contents.MatchAnyPrefix = de_MatchAnyPrefix(__getArrayIfSingleItem(output["MatchAnyPrefix"]["Prefix"]), context);
+    }
+    if (output.MatchAnySuffix === "") {
+        contents.MatchAnySuffix = [];
+    }
+    else if (output["MatchAnySuffix"] !== undefined && output["MatchAnySuffix"]["Suffix"] !== undefined) {
+        contents.MatchAnySuffix = de_MatchAnySuffix(__getArrayIfSingleItem(output["MatchAnySuffix"]["Suffix"]), context);
+    }
+    if (output.MatchAnyTag === "") {
+        contents.MatchAnyTag = [];
+    }
+    else if (output["MatchAnyTag"] !== undefined && output["MatchAnyTag"]["Tag"] !== undefined) {
+        contents.MatchAnyTag = de_MatchAnyTag(__getArrayIfSingleItem(output["MatchAnyTag"]["Tag"]), context);
+    }
+    if (output["MatchObjectAge"] !== undefined) {
+        contents.MatchObjectAge = de_MatchObjectAge(output["MatchObjectAge"], context);
+    }
+    if (output["MatchObjectSize"] !== undefined) {
+        contents.MatchObjectSize = de_MatchObjectSize(output["MatchObjectSize"], context);
+    }
+    return contents;
+};
 const de_StorageLensTag = (output, context) => {
     const contents = {};
     if (output["Key"] !== undefined) {
@@ -7367,6 +8299,23 @@ const de_StorageLensTags = (output, context) => {
         return de_StorageLensTag(entry, context);
     });
 };
+const de_Tag = (output, context) => {
+    const contents = {};
+    if (output["Key"] !== undefined) {
+        contents.Key = __expectString(output["Key"]);
+    }
+    if (output["Value"] !== undefined) {
+        contents.Value = __expectString(output["Value"]);
+    }
+    return contents;
+};
+const de_TagList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Tag(entry, context);
+    });
+};
 const de_Transition = (output, context) => {
     const contents = {};
     if (output["Date"] !== undefined) {