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

package/dist-es/protocols/Aws_restXml.js

@@ -3,8 +3,208 @@ import { HttpRequest as __HttpRequest, isValidHostname as __isValidHostname, } f
 import { collectBody, decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, expectUnion as __expectUnion, getArrayIfSingleItem as __getArrayIfSingleItem, getValueFromTextNode as __getValueFromTextNode, map, parseBoolean as __parseBoolean, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, strictParseFloat as __strictParseFloat, strictParseInt32 as __strictParseInt32, strictParseLong as __strictParseLong, withBaseException, } from "@smithy/smithy-client";
 import { XMLParser } from "fast-xml-parser";
 import { v4 as generateIdempotencyToken } from "uuid";
-import { BadRequestException, BucketAlreadyExists, BucketAlreadyOwnedByYou, IdempotencyException, InternalServiceException, InvalidNextTokenException, InvalidRequestException, JobManifestGenerator, JobStatusException, NoSuchPublicAccessBlockConfiguration, NotFoundException, ObjectLambdaContentTransformation, TooManyRequestsException, TooManyTagsException, } from "../models/models_0";
+import { BadRequestException, BucketAlreadyExists, BucketAlreadyOwnedByYou, IdempotencyException, InternalServiceException, InvalidNextTokenException, InvalidRequestException, JobManifestGenerator, NoSuchPublicAccessBlockConfiguration, NotFoundException, ObjectLambdaContentTransformation, TooManyRequestsException, } from "../models/models_0";
+import { JobStatusException, TooManyTagsException, } from "../models/models_1";
 import { S3ControlServiceException as __BaseException } from "../models/S3ControlServiceException";
+export const se_AssociateAccessGrantsIdentityCenterCommand = 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/accessgrantsinstance/identitycenter";
+    let body;
+    body = '<?xml version="1.0" encoding="UTF-8"?>';
+    const bodyNode = new __XmlNode("AssociateAccessGrantsIdentityCenterRequest");
+    bodyNode.addAttribute("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
+    if (input.IdentityCenterArn !== undefined) {
+        const node = __XmlNode.of("IdentityCenterArn", input.IdentityCenterArn).withName("IdentityCenterArn");
+        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: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_CreateAccessGrantCommand = 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/accessgrantsinstance/grant";
+    let body;
+    body = '<?xml version="1.0" encoding="UTF-8"?>';
+    const bodyNode = new __XmlNode("CreateAccessGrantRequest");
+    bodyNode.addAttribute("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
+    if (input.AccessGrantsLocationConfiguration !== undefined) {
+        const node = se_AccessGrantsLocationConfiguration(input.AccessGrantsLocationConfiguration, context).withName("AccessGrantsLocationConfiguration");
+        bodyNode.addChildNode(node);
+    }
+    if (input.AccessGrantsLocationId !== undefined) {
+        const node = __XmlNode
+            .of("AccessGrantsLocationId", input.AccessGrantsLocationId)
+            .withName("AccessGrantsLocationId");
+        bodyNode.addChildNode(node);
+    }
+    if (input.ApplicationArn !== undefined) {
+        const node = __XmlNode.of("IdentityCenterApplicationArn", input.ApplicationArn).withName("ApplicationArn");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Grantee !== undefined) {
+        const node = se_Grantee(input.Grantee, context).withName("Grantee");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Permission !== undefined) {
+        const node = __XmlNode.of("Permission", input.Permission).withName("Permission");
+        bodyNode.addChildNode(node);
+    }
+    if (input.S3PrefixType !== undefined) {
+        const node = __XmlNode.of("S3PrefixType", input.S3PrefixType).withName("S3PrefixType");
+        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_CreateAccessGrantsInstanceCommand = 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/accessgrantsinstance";
+    let body;
+    body = '<?xml version="1.0" encoding="UTF-8"?>';
+    const bodyNode = new __XmlNode("CreateAccessGrantsInstanceRequest");
+    bodyNode.addAttribute("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
+    if (input.IdentityCenterArn !== undefined) {
+        const node = __XmlNode.of("IdentityCenterArn", input.IdentityCenterArn).withName("IdentityCenterArn");
+        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_CreateAccessGrantsLocationCommand = 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/accessgrantsinstance/location";
+    let body;
+    body = '<?xml version="1.0" encoding="UTF-8"?>';
+    const bodyNode = new __XmlNode("CreateAccessGrantsLocationRequest");
+    bodyNode.addAttribute("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
+    if (input.IAMRoleArn !== undefined) {
+        const node = __XmlNode.of("IAMRoleArn", input.IAMRoleArn).withName("IAMRoleArn");
+        bodyNode.addChildNode(node);
+    }
+    if (input.LocationScope !== undefined) {
+        const node = __XmlNode.of("S3Prefix", input.LocationScope).withName("LocationScope");
+        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_CreateAccessPointCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
@@ -298,19 +498,313 @@ export const se_CreateStorageLensGroupCommand = async (input, context) => {
         protocol,
         hostname: resolvedHostname,
         port,
-        method: "POST",
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_DeleteAccessGrantCommand = 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/accessgrantsinstance/grant/{AccessGrantId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "AccessGrantId", () => input.AccessGrantId, "{AccessGrantId}", 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_DeleteAccessGrantsInstanceCommand = 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/accessgrantsinstance";
+    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_DeleteAccessGrantsInstanceResourcePolicyCommand = 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/accessgrantsinstance/resourcepolicy";
+    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_DeleteAccessGrantsLocationCommand = 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/accessgrantsinstance/location/{AccessGrantsLocationId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "AccessGrantsLocationId", () => input.AccessGrantsLocationId, "{AccessGrantsLocationId}", 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_DeleteAccessPointCommand = 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/accesspoint/{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_DeleteAccessPointForObjectLambdaCommand = 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/accesspointforobjectlambda/{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_DeleteAccessPointPolicyCommand = 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/accesspoint/{Name}/policy";
+    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_DeleteAccessPointPolicyForObjectLambdaCommand = 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/accesspointforobjectlambda/{Name}/policy";
+    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_DeleteBucketCommand = 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}";
+    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 se_DeleteBucketLifecycleConfigurationCommand = 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}/lifecycleconfiguration";
+    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 se_DeleteAccessPointCommand = async (input, context) => {
+export const se_DeleteBucketPolicyCommand = 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/accesspoint/{Name}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20180820/bucket/{Bucket}/policy";
+    resolvedPath = __resolvedPath(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -333,14 +827,13 @@ export const se_DeleteAccessPointCommand = async (input, context) => {
         body,
     });
 };
-export const se_DeleteAccessPointForObjectLambdaCommand = async (input, context) => {
+export const se_DeleteBucketReplicationCommand = 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/accesspointforobjectlambda/{Name}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
+    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) {
@@ -363,13 +856,13 @@ export const se_DeleteAccessPointForObjectLambdaCommand = async (input, context)
         body,
     });
 };
-export const se_DeleteAccessPointPolicyCommand = async (input, context) => {
+export const se_DeleteBucketTaggingCommand = 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/accesspoint/{Name}/policy";
-    resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20180820/bucket/{Bucket}/tagging";
+    resolvedPath = __resolvedPath(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -392,14 +885,13 @@ export const se_DeleteAccessPointPolicyCommand = async (input, context) => {
         body,
     });
 };
-export const se_DeleteAccessPointPolicyForObjectLambdaCommand = async (input, context) => {
+export const se_DeleteJobTaggingCommand = 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/accesspointforobjectlambda/{Name}/policy";
-    resolvedPath = __resolvedPath(resolvedPath, input, "Name", () => input.Name, "{Name}", false);
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20180820/jobs/{JobId}/tagging";
+    resolvedPath = __resolvedPath(resolvedPath, input, "JobId", () => input.JobId, "{JobId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -422,14 +914,29 @@ export const se_DeleteAccessPointPolicyForObjectLambdaCommand = async (input, co
         body,
     });
 };
-export const se_DeleteBucketCommand = async (input, context) => {
+export const se_DeleteMultiRegionAccessPointCommand = 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}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20180820/async-requests/mrap/delete";
     let body;
+    body = '<?xml version="1.0" encoding="UTF-8"?>';
+    const bodyNode = new __XmlNode("DeleteMultiRegionAccessPointRequest");
+    bodyNode.addAttribute("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken !== undefined) {
+        const node = __XmlNode.of("MultiRegionAccessPointClientToken", input.ClientToken).withName("ClientToken");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Details !== undefined) {
+        const node = se_DeleteMultiRegionAccessPointInput(input.Details, context).withName("Details");
+        bodyNode.addChildNode(node);
+    }
+    body += bodyNode.toString();
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
         resolvedHostname = "{AccountId}." + resolvedHostname;
@@ -445,20 +952,19 @@ export const se_DeleteBucketCommand = async (input, context) => {
         protocol,
         hostname: resolvedHostname,
         port,
-        method: "DELETE",
+        method: "POST",
         headers,
         path: resolvedPath,
         body,
     });
 };
-export const se_DeleteBucketLifecycleConfigurationCommand = async (input, context) => {
+export const se_DeletePublicAccessBlockCommand = 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}/lifecycleconfiguration";
-    resolvedPath = __resolvedPath(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v20180820/configuration/publicAccessBlock";
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -481,13 +987,13 @@ export const se_DeleteBucketLifecycleConfigurationCommand = async (input, contex
         body,
     });
 };
-export const se_DeleteBucketPolicyCommand = async (input, context) => {
+export const se_DeleteStorageLensConfigurationCommand = 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}/policy";
-    resolvedPath = __resolvedPath(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20180820/storagelens/{ConfigId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "ConfigId", () => input.ConfigId, "{ConfigId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -510,13 +1016,13 @@ export const se_DeleteBucketPolicyCommand = async (input, context) => {
         body,
     });
 };
-export const se_DeleteBucketReplicationCommand = async (input, context) => {
+export const se_DeleteStorageLensConfigurationTaggingCommand = 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 resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20180820/storagelens/{ConfigId}/tagging";
+    resolvedPath = __resolvedPath(resolvedPath, input, "ConfigId", () => input.ConfigId, "{ConfigId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -539,13 +1045,13 @@ export const se_DeleteBucketReplicationCommand = async (input, context) => {
         body,
     });
 };
-export const se_DeleteBucketTaggingCommand = async (input, context) => {
+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/bucket/{Bucket}/tagging";
-    resolvedPath = __resolvedPath(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false);
+    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) {
@@ -568,12 +1074,12 @@ export const se_DeleteBucketTaggingCommand = async (input, context) => {
         body,
     });
 };
-export const se_DeleteJobTaggingCommand = async (input, context) => {
+export const se_DescribeJobCommand = 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/jobs/{JobId}/tagging";
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20180820/jobs/{JobId}";
     resolvedPath = __resolvedPath(resolvedPath, input, "JobId", () => input.JobId, "{JobId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
@@ -591,35 +1097,21 @@ export const se_DeleteJobTaggingCommand = async (input, context) => {
         protocol,
         hostname: resolvedHostname,
         port,
-        method: "DELETE",
+        method: "GET",
         headers,
         path: resolvedPath,
         body,
     });
 };
-export const se_DeleteMultiRegionAccessPointCommand = async (input, context) => {
+export const se_DescribeMultiRegionAccessPointOperationCommand = 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/async-requests/mrap/delete";
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v20180820/async-requests/mrap/{RequestTokenARN+}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "RequestTokenARN", () => input.RequestTokenARN, "{RequestTokenARN+}", true);
     let body;
-    body = '<?xml version="1.0" encoding="UTF-8"?>';
-    const bodyNode = new __XmlNode("DeleteMultiRegionAccessPointRequest");
-    bodyNode.addAttribute("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
-    if (input.ClientToken === undefined) {
-        input.ClientToken = generateIdempotencyToken();
-    }
-    if (input.ClientToken !== undefined) {
-        const node = __XmlNode.of("MultiRegionAccessPointClientToken", input.ClientToken).withName("ClientToken");
-        bodyNode.addChildNode(node);
-    }
-    if (input.Details !== undefined) {
-        const node = se_DeleteMultiRegionAccessPointInput(input.Details, context).withName("Details");
-        bodyNode.addChildNode(node);
-    }
-    body += bodyNode.toString();
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
         resolvedHostname = "{AccountId}." + resolvedHostname;
@@ -635,19 +1127,19 @@ export const se_DeleteMultiRegionAccessPointCommand = async (input, context) =>
         protocol,
         hostname: resolvedHostname,
         port,
-        method: "POST",
+        method: "GET",
         headers,
         path: resolvedPath,
         body,
     });
 };
-export const se_DeletePublicAccessBlockCommand = async (input, context) => {
+export const se_DissociateAccessGrantsIdentityCenterCommand = 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/configuration/publicAccessBlock";
+        "/v20180820/accessgrantsinstance/identitycenter";
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -670,13 +1162,14 @@ export const se_DeletePublicAccessBlockCommand = async (input, context) => {
         body,
     });
 };
-export const se_DeleteStorageLensConfigurationCommand = async (input, context) => {
+export const se_GetAccessGrantCommand = 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/storagelens/{ConfigId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ConfigId", () => input.ConfigId, "{ConfigId}", false);
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v20180820/accessgrantsinstance/grant/{AccessGrantId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "AccessGrantId", () => input.AccessGrantId, "{AccessGrantId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -693,19 +1186,18 @@ export const se_DeleteStorageLensConfigurationCommand = async (input, context) =
         protocol,
         hostname: resolvedHostname,
         port,
-        method: "DELETE",
+        method: "GET",
         headers,
         path: resolvedPath,
         body,
     });
 };
-export const se_DeleteStorageLensConfigurationTaggingCommand = async (input, context) => {
+export const se_GetAccessGrantsInstanceCommand = 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/storagelens/{ConfigId}/tagging";
-    resolvedPath = __resolvedPath(resolvedPath, input, "ConfigId", () => input.ConfigId, "{ConfigId}", false);
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20180820/accessgrantsinstance";
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -722,19 +1214,21 @@ export const se_DeleteStorageLensConfigurationTaggingCommand = async (input, con
         protocol,
         hostname: resolvedHostname,
         port,
-        method: "DELETE",
+        method: "GET",
         headers,
         path: resolvedPath,
         body,
     });
 };
-export const se_DeleteStorageLensGroupCommand = async (input, context) => {
+export const se_GetAccessGrantsInstanceForPrefixCommand = 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);
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/v20180820/accessgrantsinstance/prefix";
+    const query = map({
+        s3prefix: [, __expectNonNull(input.S3Prefix, `S3Prefix`)],
+    });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -751,19 +1245,20 @@ export const se_DeleteStorageLensGroupCommand = async (input, context) => {
         protocol,
         hostname: resolvedHostname,
         port,
-        method: "DELETE",
+        method: "GET",
         headers,
         path: resolvedPath,
+        query,
         body,
     });
 };
-export const se_DescribeJobCommand = async (input, context) => {
+export const se_GetAccessGrantsInstanceResourcePolicyCommand = 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/jobs/{JobId}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "JobId", () => input.JobId, "{JobId}", false);
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/v20180820/accessgrantsinstance/resourcepolicy";
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -786,14 +1281,14 @@ export const se_DescribeJobCommand = async (input, context) => {
         body,
     });
 };
-export const se_DescribeMultiRegionAccessPointOperationCommand = async (input, context) => {
+export const se_GetAccessGrantsLocationCommand = 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/async-requests/mrap/{RequestTokenARN+}";
-    resolvedPath = __resolvedPath(resolvedPath, input, "RequestTokenARN", () => input.RequestTokenARN, "{RequestTokenARN+}", true);
+        "/v20180820/accessgrantsinstance/location/{AccessGrantsLocationId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "AccessGrantsLocationId", () => input.AccessGrantsLocationId, "{AccessGrantsLocationId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -1199,6 +1694,43 @@ export const se_GetBucketVersioningCommand = async (input, context) => {
         body,
     });
 };
+export const se_GetDataAccessCommand = 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/accessgrantsinstance/dataaccess";
+    const query = map({
+        target: [, __expectNonNull(input.Target, `Target`)],
+        permission: [, __expectNonNull(input.Permission, `Permission`)],
+        durationSeconds: [() => input.DurationSeconds !== void 0, () => input.DurationSeconds.toString()],
+        privilege: [, input.Privilege],
+        targetType: [, input.TargetType],
+    });
+    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_GetJobTaggingCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
@@ -1437,8 +1969,112 @@ export const se_GetStorageLensGroupCommand = async (input, context) => {
     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 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_ListAccessGrantsCommand = 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/accessgrantsinstance/grants";
+    const query = map({
+        nextToken: [, input.NextToken],
+        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
+        granteetype: [, input.GranteeType],
+        granteeidentifier: [, input.GranteeIdentifier],
+        permission: [, input.Permission],
+        grantscope: [, input.GrantScope],
+        application_arn: [, input.ApplicationArn],
+    });
+    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_ListAccessGrantsInstancesCommand = 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/accessgrantsinstances";
+    const query = map({
+        nextToken: [, input.NextToken],
+        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
+    });
+    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_ListAccessGrantsLocationsCommand = 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/accessgrantsinstance/locations";
+    const query = map({
+        nextToken: [, input.NextToken],
+        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
+        locationscope: [, input.LocationScope],
+    });
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -1458,6 +2094,7 @@ export const se_GetStorageLensGroupCommand = async (input, context) => {
         method: "GET",
         headers,
         path: resolvedPath,
+        query,
         body,
     });
 };
@@ -1722,6 +2359,48 @@ export const se_ListTagsForResourceCommand = async (input, context) => {
         body,
     });
 };
+export const se_PutAccessGrantsInstanceResourcePolicyCommand = 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/accessgrantsinstance/resourcepolicy";
+    let body;
+    body = '<?xml version="1.0" encoding="UTF-8"?>';
+    const bodyNode = new __XmlNode("PutAccessGrantsInstanceResourcePolicyRequest");
+    bodyNode.addAttribute("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
+    if (input.Organization !== undefined) {
+        const node = __XmlNode.of("Organization", input.Organization).withName("Organization");
+        bodyNode.addChildNode(node);
+    }
+    if (input.Policy !== undefined) {
+        const node = __XmlNode.of("PolicyDocument", input.Policy).withName("Policy");
+        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 se_PutAccessPointConfigurationForObjectLambdaCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
@@ -2376,6 +3055,45 @@ export const se_UntagResourceCommand = async (input, context) => {
         body,
     });
 };
+export const se_UpdateAccessGrantsLocationCommand = 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/accessgrantsinstance/location/{AccessGrantsLocationId}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "AccessGrantsLocationId", () => input.AccessGrantsLocationId, "{AccessGrantsLocationId}", false);
+    let body;
+    body = '<?xml version="1.0" encoding="UTF-8"?>';
+    const bodyNode = new __XmlNode("UpdateAccessGrantsLocationRequest");
+    bodyNode.addAttribute("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
+    if (input.IAMRoleArn !== undefined) {
+        const node = __XmlNode.of("IAMRoleArn", input.IAMRoleArn).withName("IAMRoleArn");
+        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 se_UpdateJobPriorityCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
@@ -2481,6 +3199,152 @@ export const se_UpdateStorageLensGroupCommand = async (input, context) => {
         body,
     });
 };
+export const de_AssociateAccessGrantsIdentityCenterCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_AssociateAccessGrantsIdentityCenterCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_AssociateAccessGrantsIdentityCenterCommandError = 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_CreateAccessGrantCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CreateAccessGrantCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data["AccessGrantArn"] !== undefined) {
+        contents.AccessGrantArn = __expectString(data["AccessGrantArn"]);
+    }
+    if (data["AccessGrantId"] !== undefined) {
+        contents.AccessGrantId = __expectString(data["AccessGrantId"]);
+    }
+    if (data["AccessGrantsLocationConfiguration"] !== undefined) {
+        contents.AccessGrantsLocationConfiguration = de_AccessGrantsLocationConfiguration(data["AccessGrantsLocationConfiguration"], context);
+    }
+    if (data["AccessGrantsLocationId"] !== undefined) {
+        contents.AccessGrantsLocationId = __expectString(data["AccessGrantsLocationId"]);
+    }
+    if (data["ApplicationArn"] !== undefined) {
+        contents.ApplicationArn = __expectString(data["ApplicationArn"]);
+    }
+    if (data["CreatedAt"] !== undefined) {
+        contents.CreatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data["CreatedAt"]));
+    }
+    if (data["GrantScope"] !== undefined) {
+        contents.GrantScope = __expectString(data["GrantScope"]);
+    }
+    if (data["Grantee"] !== undefined) {
+        contents.Grantee = de_Grantee(data["Grantee"], context);
+    }
+    if (data["Permission"] !== undefined) {
+        contents.Permission = __expectString(data["Permission"]);
+    }
+    return contents;
+};
+const de_CreateAccessGrantCommandError = 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_CreateAccessGrantsInstanceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CreateAccessGrantsInstanceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data["AccessGrantsInstanceArn"] !== undefined) {
+        contents.AccessGrantsInstanceArn = __expectString(data["AccessGrantsInstanceArn"]);
+    }
+    if (data["AccessGrantsInstanceId"] !== undefined) {
+        contents.AccessGrantsInstanceId = __expectString(data["AccessGrantsInstanceId"]);
+    }
+    if (data["CreatedAt"] !== undefined) {
+        contents.CreatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data["CreatedAt"]));
+    }
+    if (data["IdentityCenterArn"] !== undefined) {
+        contents.IdentityCenterArn = __expectString(data["IdentityCenterArn"]);
+    }
+    return contents;
+};
+const de_CreateAccessGrantsInstanceCommandError = 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_CreateAccessGrantsLocationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CreateAccessGrantsLocationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data["AccessGrantsLocationArn"] !== undefined) {
+        contents.AccessGrantsLocationArn = __expectString(data["AccessGrantsLocationArn"]);
+    }
+    if (data["AccessGrantsLocationId"] !== undefined) {
+        contents.AccessGrantsLocationId = __expectString(data["AccessGrantsLocationId"]);
+    }
+    if (data["CreatedAt"] !== undefined) {
+        contents.CreatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data["CreatedAt"]));
+    }
+    if (data["IAMRoleArn"] !== undefined) {
+        contents.IAMRoleArn = __expectString(data["IAMRoleArn"]);
+    }
+    if (data["LocationScope"] !== undefined) {
+        contents.LocationScope = __expectString(data["LocationScope"]);
+    }
+    return contents;
+};
+const de_CreateAccessGrantsLocationCommandError = 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_CreateAccessPointCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CreateAccessPointCommandError(output, context);
@@ -2629,7 +3493,99 @@ export const de_CreateMultiRegionAccessPointCommand = async (output, context) =>
     }
     return contents;
 };
-const de_CreateMultiRegionAccessPointCommandError = async (output, context) => {
+const de_CreateMultiRegionAccessPointCommandError = 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_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_DeleteAccessGrantCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteAccessGrantCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_DeleteAccessGrantCommandError = 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_DeleteAccessGrantsInstanceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteAccessGrantsInstanceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_DeleteAccessGrantsInstanceCommandError = 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_DeleteAccessGrantsInstanceResourcePolicyCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteAccessGrantsInstanceResourcePolicyCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_DeleteAccessGrantsInstanceResourcePolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -2642,9 +3598,9 @@ 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);
+export const de_DeleteAccessGrantsLocationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteAccessGrantsLocationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -2652,7 +3608,7 @@ export const de_CreateStorageLensGroupCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
-const de_CreateStorageLensGroupCommandError = async (output, context) => {
+const de_DeleteAccessGrantsLocationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3092,6 +4048,213 @@ const de_DescribeMultiRegionAccessPointOperationCommandError = async (output, co
         errorCode,
     });
 };
+export const de_DissociateAccessGrantsIdentityCenterCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DissociateAccessGrantsIdentityCenterCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const de_DissociateAccessGrantsIdentityCenterCommandError = 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_GetAccessGrantCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetAccessGrantCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data["AccessGrantArn"] !== undefined) {
+        contents.AccessGrantArn = __expectString(data["AccessGrantArn"]);
+    }
+    if (data["AccessGrantId"] !== undefined) {
+        contents.AccessGrantId = __expectString(data["AccessGrantId"]);
+    }
+    if (data["AccessGrantsLocationConfiguration"] !== undefined) {
+        contents.AccessGrantsLocationConfiguration = de_AccessGrantsLocationConfiguration(data["AccessGrantsLocationConfiguration"], context);
+    }
+    if (data["AccessGrantsLocationId"] !== undefined) {
+        contents.AccessGrantsLocationId = __expectString(data["AccessGrantsLocationId"]);
+    }
+    if (data["ApplicationArn"] !== undefined) {
+        contents.ApplicationArn = __expectString(data["ApplicationArn"]);
+    }
+    if (data["CreatedAt"] !== undefined) {
+        contents.CreatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data["CreatedAt"]));
+    }
+    if (data["GrantScope"] !== undefined) {
+        contents.GrantScope = __expectString(data["GrantScope"]);
+    }
+    if (data["Grantee"] !== undefined) {
+        contents.Grantee = de_Grantee(data["Grantee"], context);
+    }
+    if (data["Permission"] !== undefined) {
+        contents.Permission = __expectString(data["Permission"]);
+    }
+    return contents;
+};
+const de_GetAccessGrantCommandError = 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_GetAccessGrantsInstanceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetAccessGrantsInstanceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data["AccessGrantsInstanceArn"] !== undefined) {
+        contents.AccessGrantsInstanceArn = __expectString(data["AccessGrantsInstanceArn"]);
+    }
+    if (data["AccessGrantsInstanceId"] !== undefined) {
+        contents.AccessGrantsInstanceId = __expectString(data["AccessGrantsInstanceId"]);
+    }
+    if (data["CreatedAt"] !== undefined) {
+        contents.CreatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data["CreatedAt"]));
+    }
+    if (data["IdentityCenterArn"] !== undefined) {
+        contents.IdentityCenterArn = __expectString(data["IdentityCenterArn"]);
+    }
+    return contents;
+};
+const de_GetAccessGrantsInstanceCommandError = 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_GetAccessGrantsInstanceForPrefixCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetAccessGrantsInstanceForPrefixCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data["AccessGrantsInstanceArn"] !== undefined) {
+        contents.AccessGrantsInstanceArn = __expectString(data["AccessGrantsInstanceArn"]);
+    }
+    if (data["AccessGrantsInstanceId"] !== undefined) {
+        contents.AccessGrantsInstanceId = __expectString(data["AccessGrantsInstanceId"]);
+    }
+    return contents;
+};
+const de_GetAccessGrantsInstanceForPrefixCommandError = 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_GetAccessGrantsInstanceResourcePolicyCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetAccessGrantsInstanceResourcePolicyCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data["CreatedAt"] !== undefined) {
+        contents.CreatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data["CreatedAt"]));
+    }
+    if (data["Organization"] !== undefined) {
+        contents.Organization = __expectString(data["Organization"]);
+    }
+    if (data["Policy"] !== undefined) {
+        contents.Policy = __expectString(data["Policy"]);
+    }
+    return contents;
+};
+const de_GetAccessGrantsInstanceResourcePolicyCommandError = 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_GetAccessGrantsLocationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetAccessGrantsLocationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data["AccessGrantsLocationArn"] !== undefined) {
+        contents.AccessGrantsLocationArn = __expectString(data["AccessGrantsLocationArn"]);
+    }
+    if (data["AccessGrantsLocationId"] !== undefined) {
+        contents.AccessGrantsLocationId = __expectString(data["AccessGrantsLocationId"]);
+    }
+    if (data["CreatedAt"] !== undefined) {
+        contents.CreatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data["CreatedAt"]));
+    }
+    if (data["IAMRoleArn"] !== undefined) {
+        contents.IAMRoleArn = __expectString(data["IAMRoleArn"]);
+    }
+    if (data["LocationScope"] !== undefined) {
+        contents.LocationScope = __expectString(data["LocationScope"]);
+    }
+    return contents;
+};
+const de_GetAccessGrantsLocationCommandError = 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_GetAccessPointCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_GetAccessPointCommandError(output, context);
@@ -3484,6 +4647,35 @@ const de_GetBucketVersioningCommandError = async (output, context) => {
         errorCode,
     });
 };
+export const de_GetDataAccessCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetDataAccessCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data["Credentials"] !== undefined) {
+        contents.Credentials = de_Credentials(data["Credentials"], context);
+    }
+    if (data["MatchedGrantTarget"] !== undefined) {
+        contents.MatchedGrantTarget = __expectString(data["MatchedGrantTarget"]);
+    }
+    return contents;
+};
+const de_GetDataAccessCommandError = 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_GetJobTaggingCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_GetJobTaggingCommandError(output, context);
@@ -3646,37 +4838,122 @@ export const de_GetPublicAccessBlockCommand = async (output, context) => {
     contents.PublicAccessBlockConfiguration = de_PublicAccessBlockConfiguration(data, context);
     return contents;
 };
-const de_GetPublicAccessBlockCommandError = async (output, context) => {
+const de_GetPublicAccessBlockCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestXmlErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "NoSuchPublicAccessBlockConfiguration":
+        case "com.amazonaws.s3control#NoSuchPublicAccessBlockConfiguration":
+            throw await de_NoSuchPublicAccessBlockConfigurationRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody: parsedBody.Error,
+                errorCode,
+            });
+    }
+};
+export const de_GetStorageLensConfigurationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetStorageLensConfigurationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectObject(await parseBody(output.body, context));
+    contents.StorageLensConfiguration = de_StorageLensConfiguration(data, context);
+    return contents;
+};
+const de_GetStorageLensConfigurationCommandError = 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_GetStorageLensConfigurationTaggingCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetStorageLensConfigurationTaggingCommandError(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_StorageLensTags(__getArrayIfSingleItem(data["Tags"]["Tag"]), context);
+    }
+    return contents;
+};
+const de_GetStorageLensConfigurationTaggingCommandError = 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_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);
-    switch (errorCode) {
-        case "NoSuchPublicAccessBlockConfiguration":
-        case "com.amazonaws.s3control#NoSuchPublicAccessBlockConfiguration":
-            throw await de_NoSuchPublicAccessBlockConfigurationRes(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody: parsedBody.Error,
-                errorCode,
-            });
-    }
+    const parsedBody = parsedOutput.body;
+    return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode,
+    });
 };
-export const de_GetStorageLensConfigurationCommand = async (output, context) => {
+export const de_ListAccessGrantsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetStorageLensConfigurationCommandError(output, context);
+        return de_ListAccessGrantsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectObject(await parseBody(output.body, context));
-    contents.StorageLensConfiguration = de_StorageLensConfiguration(data, context);
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.AccessGrantsList === "") {
+        contents.AccessGrantsList = [];
+    }
+    else if (data["AccessGrantsList"] !== undefined && data["AccessGrantsList"]["AccessGrant"] !== undefined) {
+        contents.AccessGrantsList = de_AccessGrantsList(__getArrayIfSingleItem(data["AccessGrantsList"]["AccessGrant"]), context);
+    }
+    if (data["NextToken"] !== undefined) {
+        contents.NextToken = __expectString(data["NextToken"]);
+    }
     return contents;
 };
-const de_GetStorageLensConfigurationCommandError = async (output, context) => {
+const de_ListAccessGrantsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3689,23 +4966,27 @@ const de_GetStorageLensConfigurationCommandError = async (output, context) => {
         errorCode,
     });
 };
-export const de_GetStorageLensConfigurationTaggingCommand = async (output, context) => {
+export const de_ListAccessGrantsInstancesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetStorageLensConfigurationTaggingCommandError(output, context);
+        return de_ListAccessGrantsInstancesCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
-    if (data.Tags === "") {
-        contents.Tags = [];
+    if (data.AccessGrantsInstancesList === "") {
+        contents.AccessGrantsInstancesList = [];
     }
-    else if (data["Tags"] !== undefined && data["Tags"]["Tag"] !== undefined) {
-        contents.Tags = de_StorageLensTags(__getArrayIfSingleItem(data["Tags"]["Tag"]), context);
+    else if (data["AccessGrantsInstancesList"] !== undefined &&
+        data["AccessGrantsInstancesList"]["AccessGrantsInstance"] !== undefined) {
+        contents.AccessGrantsInstancesList = de_AccessGrantsInstancesList(__getArrayIfSingleItem(data["AccessGrantsInstancesList"]["AccessGrantsInstance"]), context);
+    }
+    if (data["NextToken"] !== undefined) {
+        contents.NextToken = __expectString(data["NextToken"]);
     }
     return contents;
 };
-const de_GetStorageLensConfigurationTaggingCommandError = async (output, context) => {
+const de_ListAccessGrantsInstancesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -3718,18 +4999,27 @@ const de_GetStorageLensConfigurationTaggingCommandError = async (output, context
         errorCode,
     });
 };
-export const de_GetStorageLensGroupCommand = async (output, context) => {
+export const de_ListAccessGrantsLocationsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_GetStorageLensGroupCommandError(output, context);
+        return de_ListAccessGrantsLocationsCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
-    const data = __expectObject(await parseBody(output.body, context));
-    contents.StorageLensGroup = de_StorageLensGroup(data, context);
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.AccessGrantsLocationsList === "") {
+        contents.AccessGrantsLocationsList = [];
+    }
+    else if (data["AccessGrantsLocationsList"] !== undefined &&
+        data["AccessGrantsLocationsList"]["AccessGrantsLocation"] !== undefined) {
+        contents.AccessGrantsLocationsList = de_AccessGrantsLocationsList(__getArrayIfSingleItem(data["AccessGrantsLocationsList"]["AccessGrantsLocation"]), context);
+    }
+    if (data["NextToken"] !== undefined) {
+        contents.NextToken = __expectString(data["NextToken"]);
+    }
     return contents;
 };
-const de_GetStorageLensGroupCommandError = async (output, context) => {
+const de_ListAccessGrantsLocationsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -4008,6 +5298,38 @@ const de_ListTagsForResourceCommandError = async (output, context) => {
         errorCode,
     });
 };
+export const de_PutAccessGrantsInstanceResourcePolicyCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_PutAccessGrantsInstanceResourcePolicyCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data["CreatedAt"] !== undefined) {
+        contents.CreatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data["CreatedAt"]));
+    }
+    if (data["Organization"] !== undefined) {
+        contents.Organization = __expectString(data["Organization"]);
+    }
+    if (data["Policy"] !== undefined) {
+        contents.Policy = __expectString(data["Policy"]);
+    }
+    return contents;
+};
+const de_PutAccessGrantsInstanceResourcePolicyCommandError = 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);
@@ -4394,6 +5716,44 @@ const de_UntagResourceCommandError = async (output, context) => {
         errorCode,
     });
 };
+export const de_UpdateAccessGrantsLocationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_UpdateAccessGrantsLocationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data["AccessGrantsLocationArn"] !== undefined) {
+        contents.AccessGrantsLocationArn = __expectString(data["AccessGrantsLocationArn"]);
+    }
+    if (data["AccessGrantsLocationId"] !== undefined) {
+        contents.AccessGrantsLocationId = __expectString(data["AccessGrantsLocationId"]);
+    }
+    if (data["CreatedAt"] !== undefined) {
+        contents.CreatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data["CreatedAt"]));
+    }
+    if (data["IAMRoleArn"] !== undefined) {
+        contents.IAMRoleArn = __expectString(data["IAMRoleArn"]);
+    }
+    if (data["LocationScope"] !== undefined) {
+        contents.LocationScope = __expectString(data["LocationScope"]);
+    }
+    return contents;
+};
+const de_UpdateAccessGrantsLocationCommandError = 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);
@@ -4666,6 +6026,14 @@ const se_AccessControlTranslation = (input, context) => {
     }
     return bodyNode;
 };
+const se_AccessGrantsLocationConfiguration = (input, context) => {
+    const bodyNode = new __XmlNode("AccessGrantsLocationConfiguration");
+    if (input.S3SubPrefix != null) {
+        const node = __XmlNode.of("S3Prefix", input.S3SubPrefix).withName("S3SubPrefix");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const se_AccountLevel = (input, context) => {
     const bodyNode = new __XmlNode("AccountLevel");
     if (input.ActivityMetrics != null) {
@@ -4902,6 +6270,18 @@ const se_GeneratedManifestEncryption = (input, context) => {
     }
     return bodyNode;
 };
+const se_Grantee = (input, context) => {
+    const bodyNode = new __XmlNode("Grantee");
+    if (input.GranteeType != null) {
+        const node = __XmlNode.of("GranteeType", input.GranteeType).withName("GranteeType");
+        bodyNode.addChildNode(node);
+    }
+    if (input.GranteeIdentifier != null) {
+        const node = __XmlNode.of("GranteeIdentifier", input.GranteeIdentifier).withName("GranteeIdentifier");
+        bodyNode.addChildNode(node);
+    }
+    return bodyNode;
+};
 const se_Include = (input, context) => {
     const bodyNode = new __XmlNode("Include");
     if (input.Buckets != null) {
@@ -4984,6 +6364,30 @@ const se_JobManifestGeneratorFilter = (input, context) => {
         });
         bodyNode.addChildNode(containerNode);
     }
+    if (input.KeyNameConstraint != null) {
+        const node = se_KeyNameConstraint(input.KeyNameConstraint, context).withName("KeyNameConstraint");
+        bodyNode.addChildNode(node);
+    }
+    if (input.ObjectSizeGreaterThanBytes != null) {
+        const node = __XmlNode
+            .of("ObjectSizeGreaterThanBytes", String(input.ObjectSizeGreaterThanBytes))
+            .withName("ObjectSizeGreaterThanBytes");
+        bodyNode.addChildNode(node);
+    }
+    if (input.ObjectSizeLessThanBytes != null) {
+        const node = __XmlNode
+            .of("ObjectSizeLessThanBytes", String(input.ObjectSizeLessThanBytes))
+            .withName("ObjectSizeLessThanBytes");
+        bodyNode.addChildNode(node);
+    }
+    if (input.MatchAnyStorageClass != null) {
+        const nodes = se_StorageClassList(input.MatchAnyStorageClass, context);
+        const containerNode = new __XmlNode("MatchAnyStorageClass");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
     return bodyNode;
 };
 const se_JobManifestLocation = (input, context) => {
@@ -5082,6 +6486,34 @@ const se_JobReport = (input, context) => {
     }
     return bodyNode;
 };
+const se_KeyNameConstraint = (input, context) => {
+    const bodyNode = new __XmlNode("KeyNameConstraint");
+    if (input.MatchAnyPrefix != null) {
+        const nodes = se_NonEmptyMaxLength1024StringList(input.MatchAnyPrefix, context);
+        const containerNode = new __XmlNode("MatchAnyPrefix");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    if (input.MatchAnySuffix != null) {
+        const nodes = se_NonEmptyMaxLength1024StringList(input.MatchAnySuffix, context);
+        const containerNode = new __XmlNode("MatchAnySuffix");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    if (input.MatchAnySubstring != null) {
+        const nodes = se_NonEmptyMaxLength1024StringList(input.MatchAnySubstring, context);
+        const containerNode = new __XmlNode("MatchAnySubstring");
+        nodes.map((node) => {
+            containerNode.addChildNode(node);
+        });
+        bodyNode.addChildNode(containerNode);
+    }
+    return bodyNode;
+};
 const se_LambdaInvokeOperation = (input, context) => {
     const bodyNode = new __XmlNode("LambdaInvokeOperation");
     if (input.FunctionArn != null) {
@@ -5340,6 +6772,14 @@ const se_NoncurrentVersionTransitionList = (input, context) => {
         return node.withName("NoncurrentVersionTransition");
     });
 };
+const se_NonEmptyMaxLength1024StringList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        const node = __XmlNode.of("NonEmptyMaxLength1024String", entry);
+        return node.withName("member");
+    });
+};
 const se_ObjectLambdaAllowedFeaturesList = (input, context) => {
     return input
         .filter((e) => e != null)
@@ -6129,6 +7569,14 @@ const se_SSES3Encryption = (input, context) => {
     const bodyNode = new __XmlNode("SSE-S3");
     return bodyNode;
 };
+const se_StorageClassList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        const node = __XmlNode.of("S3StorageClass", entry);
+        return node.withName("member");
+    });
+};
 const se_StorageLensAwsOrg = (input, context) => {
     const bodyNode = new __XmlNode("StorageLensAwsOrg");
     if (input.Arn != null) {
@@ -6483,6 +7931,34 @@ const de_AccessControlTranslation = (output, context) => {
     }
     return contents;
 };
+const de_AccessGrantsInstancesList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ListAccessGrantsInstanceEntry(entry, context);
+    });
+};
+const de_AccessGrantsList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ListAccessGrantEntry(entry, context);
+    });
+};
+const de_AccessGrantsLocationConfiguration = (output, context) => {
+    const contents = {};
+    if (output["S3SubPrefix"] !== undefined) {
+        contents.S3SubPrefix = __expectString(output["S3SubPrefix"]);
+    }
+    return contents;
+};
+const de_AccessGrantsLocationsList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ListAccessGrantsLocationsEntry(entry, context);
+    });
+};
 const de_AccessPoint = (output, context) => {
     const contents = {};
     if (output["Name"] !== undefined) {
@@ -6678,6 +8154,22 @@ const de_CreateMultiRegionAccessPointInput = (output, context) => {
     }
     return contents;
 };
+const de_Credentials = (output, context) => {
+    const contents = {};
+    if (output["AccessKeyId"] !== undefined) {
+        contents.AccessKeyId = __expectString(output["AccessKeyId"]);
+    }
+    if (output["SecretAccessKey"] !== undefined) {
+        contents.SecretAccessKey = __expectString(output["SecretAccessKey"]);
+    }
+    if (output["SessionToken"] !== undefined) {
+        contents.SessionToken = __expectString(output["SessionToken"]);
+    }
+    if (output["Expiration"] !== undefined) {
+        contents.Expiration = __expectNonNull(__parseRfc3339DateTimeWithOffset(output["Expiration"]));
+    }
+    return contents;
+};
 const de_DeleteMarkerReplication = (output, context) => {
     const contents = {};
     if (output["Status"] !== undefined) {
@@ -6780,6 +8272,16 @@ const de_GeneratedManifestEncryption = (output, context) => {
     }
     return contents;
 };
+const de_Grantee = (output, context) => {
+    const contents = {};
+    if (output["GranteeType"] !== undefined) {
+        contents.GranteeType = __expectString(output["GranteeType"]);
+    }
+    if (output["GranteeIdentifier"] !== undefined) {
+        contents.GranteeIdentifier = __expectString(output["GranteeIdentifier"]);
+    }
+    return contents;
+};
 const de_Include = (output, context) => {
     const contents = {};
     if (output.Buckets === "") {
@@ -6957,6 +8459,21 @@ const de_JobManifestGeneratorFilter = (output, context) => {
         output["ObjectReplicationStatuses"]["member"] !== undefined) {
         contents.ObjectReplicationStatuses = de_ReplicationStatusFilterList(__getArrayIfSingleItem(output["ObjectReplicationStatuses"]["member"]), context);
     }
+    if (output["KeyNameConstraint"] !== undefined) {
+        contents.KeyNameConstraint = de_KeyNameConstraint(output["KeyNameConstraint"], context);
+    }
+    if (output["ObjectSizeGreaterThanBytes"] !== undefined) {
+        contents.ObjectSizeGreaterThanBytes = __strictParseLong(output["ObjectSizeGreaterThanBytes"]);
+    }
+    if (output["ObjectSizeLessThanBytes"] !== undefined) {
+        contents.ObjectSizeLessThanBytes = __strictParseLong(output["ObjectSizeLessThanBytes"]);
+    }
+    if (output.MatchAnyStorageClass === "") {
+        contents.MatchAnyStorageClass = [];
+    }
+    else if (output["MatchAnyStorageClass"] !== undefined && output["MatchAnyStorageClass"]["member"] !== undefined) {
+        contents.MatchAnyStorageClass = de_StorageClassList(__getArrayIfSingleItem(output["MatchAnyStorageClass"]["member"]), context);
+    }
     return contents;
 };
 const de_JobManifestLocation = (output, context) => {
@@ -7058,6 +8575,28 @@ const de_JobTimers = (output, context) => {
     }
     return contents;
 };
+const de_KeyNameConstraint = (output, context) => {
+    const contents = {};
+    if (output.MatchAnyPrefix === "") {
+        contents.MatchAnyPrefix = [];
+    }
+    else if (output["MatchAnyPrefix"] !== undefined && output["MatchAnyPrefix"]["member"] !== undefined) {
+        contents.MatchAnyPrefix = de_NonEmptyMaxLength1024StringList(__getArrayIfSingleItem(output["MatchAnyPrefix"]["member"]), context);
+    }
+    if (output.MatchAnySuffix === "") {
+        contents.MatchAnySuffix = [];
+    }
+    else if (output["MatchAnySuffix"] !== undefined && output["MatchAnySuffix"]["member"] !== undefined) {
+        contents.MatchAnySuffix = de_NonEmptyMaxLength1024StringList(__getArrayIfSingleItem(output["MatchAnySuffix"]["member"]), context);
+    }
+    if (output.MatchAnySubstring === "") {
+        contents.MatchAnySubstring = [];
+    }
+    else if (output["MatchAnySubstring"] !== undefined && output["MatchAnySubstring"]["member"] !== undefined) {
+        contents.MatchAnySubstring = de_NonEmptyMaxLength1024StringList(__getArrayIfSingleItem(output["MatchAnySubstring"]["member"]), context);
+    }
+    return contents;
+};
 const de_LambdaInvokeOperation = (output, context) => {
     const contents = {};
     if (output["FunctionArn"] !== undefined) {
@@ -7158,6 +8697,72 @@ const de_LifecycleRules = (output, context) => {
         return de_LifecycleRule(entry, context);
     });
 };
+const de_ListAccessGrantEntry = (output, context) => {
+    const contents = {};
+    if (output["CreatedAt"] !== undefined) {
+        contents.CreatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(output["CreatedAt"]));
+    }
+    if (output["AccessGrantId"] !== undefined) {
+        contents.AccessGrantId = __expectString(output["AccessGrantId"]);
+    }
+    if (output["AccessGrantArn"] !== undefined) {
+        contents.AccessGrantArn = __expectString(output["AccessGrantArn"]);
+    }
+    if (output["Grantee"] !== undefined) {
+        contents.Grantee = de_Grantee(output["Grantee"], context);
+    }
+    if (output["Permission"] !== undefined) {
+        contents.Permission = __expectString(output["Permission"]);
+    }
+    if (output["AccessGrantsLocationId"] !== undefined) {
+        contents.AccessGrantsLocationId = __expectString(output["AccessGrantsLocationId"]);
+    }
+    if (output["AccessGrantsLocationConfiguration"] !== undefined) {
+        contents.AccessGrantsLocationConfiguration = de_AccessGrantsLocationConfiguration(output["AccessGrantsLocationConfiguration"], context);
+    }
+    if (output["GrantScope"] !== undefined) {
+        contents.GrantScope = __expectString(output["GrantScope"]);
+    }
+    if (output["ApplicationArn"] !== undefined) {
+        contents.ApplicationArn = __expectString(output["ApplicationArn"]);
+    }
+    return contents;
+};
+const de_ListAccessGrantsInstanceEntry = (output, context) => {
+    const contents = {};
+    if (output["AccessGrantsInstanceId"] !== undefined) {
+        contents.AccessGrantsInstanceId = __expectString(output["AccessGrantsInstanceId"]);
+    }
+    if (output["AccessGrantsInstanceArn"] !== undefined) {
+        contents.AccessGrantsInstanceArn = __expectString(output["AccessGrantsInstanceArn"]);
+    }
+    if (output["CreatedAt"] !== undefined) {
+        contents.CreatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(output["CreatedAt"]));
+    }
+    if (output["IdentityCenterArn"] !== undefined) {
+        contents.IdentityCenterArn = __expectString(output["IdentityCenterArn"]);
+    }
+    return contents;
+};
+const de_ListAccessGrantsLocationsEntry = (output, context) => {
+    const contents = {};
+    if (output["CreatedAt"] !== undefined) {
+        contents.CreatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(output["CreatedAt"]));
+    }
+    if (output["AccessGrantsLocationId"] !== undefined) {
+        contents.AccessGrantsLocationId = __expectString(output["AccessGrantsLocationId"]);
+    }
+    if (output["AccessGrantsLocationArn"] !== undefined) {
+        contents.AccessGrantsLocationArn = __expectString(output["AccessGrantsLocationArn"]);
+    }
+    if (output["LocationScope"] !== undefined) {
+        contents.LocationScope = __expectString(output["LocationScope"]);
+    }
+    if (output["IAMRoleArn"] !== undefined) {
+        contents.IAMRoleArn = __expectString(output["IAMRoleArn"]);
+    }
+    return contents;
+};
 const de_ListStorageLensConfigurationEntry = (output, context) => {
     const contents = {};
     if (output["Id"] !== undefined) {
@@ -7347,6 +8952,13 @@ const de_NoncurrentVersionTransitionList = (output, context) => {
         return de_NoncurrentVersionTransition(entry, context);
     });
 };
+const de_NonEmptyMaxLength1024StringList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return __expectString(entry);
+    });
+};
 const de_ObjectLambdaAccessPoint = (output, context) => {
     const contents = {};
     if (output["Name"] !== undefined) {
@@ -8073,6 +9685,13 @@ const de_SSES3Encryption = (output, context) => {
     const contents = {};
     return contents;
 };
+const de_StorageClassList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return __expectString(entry);
+    });
+};
 const de_StorageLensAwsOrg = (output, context) => {
     const contents = {};
     if (output["Arn"] !== undefined) {