@aws-sdk/client-s3-control/dist-cjs/index.js

AWS SDK for JavaScript S3 Control Client for Node.js, Browser and React Native

'use strict';

var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
var middlewareLogger = require('@aws-sdk/middleware-logger');
var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
var middlewareSdkS3Control = require('@aws-sdk/middleware-sdk-s3-control');
var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
var configResolver = require('@smithy/config-resolver');
var core = require('@smithy/core');
var middlewareContentLength = require('@smithy/middleware-content-length');
var middlewareEndpoint = require('@smithy/middleware-endpoint');
var middlewareRetry = require('@smithy/middleware-retry');
var smithyClient = require('@smithy/smithy-client');
var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
var runtimeConfig = require('./runtimeConfig');
var regionConfigResolver = require('@aws-sdk/region-config-resolver');
var protocolHttp = require('@smithy/protocol-http');
var middlewareApplyBodyChecksum = require('@smithy/middleware-apply-body-checksum');
var middlewareSerde = require('@smithy/middleware-serde');
var core$1 = require('@aws-sdk/core');
var xmlBuilder = require('@aws-sdk/xml-builder');
var uuid = require('@smithy/uuid');

const resolveClientEndpointParameters = (options) => {
    return Object.assign(options, {
        useFipsEndpoint: options.useFipsEndpoint ?? false,
        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
        defaultSigningName: "s3",
    });
};
const commonParams = {
    UseArnRegion: { type: "clientContextParams", name: "useArnRegion" },
    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
    Endpoint: { type: "builtInParams", name: "endpoint" },
    Region: { type: "builtInParams", name: "region" },
    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
};

const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
    let _credentials = runtimeConfig.credentials;
    return {
        setHttpAuthScheme(httpAuthScheme) {
            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
            if (index === -1) {
                _httpAuthSchemes.push(httpAuthScheme);
            }
            else {
                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
            }
        },
        httpAuthSchemes() {
            return _httpAuthSchemes;
        },
        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
            _httpAuthSchemeProvider = httpAuthSchemeProvider;
        },
        httpAuthSchemeProvider() {
            return _httpAuthSchemeProvider;
        },
        setCredentials(credentials) {
            _credentials = credentials;
        },
        credentials() {
            return _credentials;
        },
    };
};
const resolveHttpAuthRuntimeConfig = (config) => {
    return {
        httpAuthSchemes: config.httpAuthSchemes(),
        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
        credentials: config.credentials(),
    };
};

const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
    extensions.forEach((extension) => extension.configure(extensionConfiguration));
    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
};

class S3ControlClient extends smithyClient.Client {
    config;
    constructor(...[configuration]) {
        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
        super(_config_0);
        this.initConfig = _config_0;
        const _config_1 = resolveClientEndpointParameters(_config_0);
        const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
        const _config_4 = configResolver.resolveRegionConfig(_config_3);
        const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
        const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
        const _config_7 = middlewareSdkS3Control.resolveS3ControlConfig(_config_6);
        const _config_8 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_7);
        const _config_9 = resolveRuntimeExtensions(_config_8, configuration?.extensions || []);
        this.config = _config_9;
        this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
        this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
        this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
        this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
        this.middlewareStack.use(middlewareSdkS3Control.getHostPrefixDeduplicationPlugin(this.config));
        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultS3ControlHttpAuthSchemeParametersProvider,
            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
                "aws.auth#sigv4": config.credentials,
            }),
        }));
        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
    }
    destroy() {
        super.destroy();
    }
}

class S3ControlServiceException extends smithyClient.ServiceException {
    constructor(options) {
        super(options);
        Object.setPrototypeOf(this, S3ControlServiceException.prototype);
    }
}

const OwnerOverride = {
    Destination: "Destination",
};
const GranteeType = {
    DIRECTORY_GROUP: "DIRECTORY_GROUP",
    DIRECTORY_USER: "DIRECTORY_USER",
    IAM: "IAM",
};
const Permission = {
    READ: "READ",
    READWRITE: "READWRITE",
    WRITE: "WRITE",
};
const NetworkOrigin = {
    Internet: "Internet",
    VPC: "VPC",
};
const AsyncOperationName = {
    CreateMultiRegionAccessPoint: "CreateMultiRegionAccessPoint",
    DeleteMultiRegionAccessPoint: "DeleteMultiRegionAccessPoint",
    PutMultiRegionAccessPointPolicy: "PutMultiRegionAccessPointPolicy",
};
const S3PrefixType = {
    Object: "Object",
};
const ScopePermission = {
    AbortMultipartUpload: "AbortMultipartUpload",
    DeleteObject: "DeleteObject",
    GetObject: "GetObject",
    GetObjectAttributes: "GetObjectAttributes",
    ListBucket: "ListBucket",
    ListBucketMultipartUploads: "ListBucketMultipartUploads",
    ListMultipartUploadParts: "ListMultipartUploadParts",
    PutObject: "PutObject",
};
const ObjectLambdaAllowedFeature = {
    GetObjectPartNumber: "GetObject-PartNumber",
    GetObjectRange: "GetObject-Range",
    HeadObjectPartNumber: "HeadObject-PartNumber",
    HeadObjectRange: "HeadObject-Range",
};
const ObjectLambdaTransformationConfigurationAction = {
    GetObject: "GetObject",
    HeadObject: "HeadObject",
    ListObjects: "ListObjects",
    ListObjectsV2: "ListObjectsV2",
};
exports.ObjectLambdaContentTransformation = void 0;
(function (ObjectLambdaContentTransformation) {
    ObjectLambdaContentTransformation.visit = (value, visitor) => {
        if (value.AwsLambda !== undefined)
            return visitor.AwsLambda(value.AwsLambda);
        return visitor._(value.$unknown[0], value.$unknown[1]);
    };
})(exports.ObjectLambdaContentTransformation || (exports.ObjectLambdaContentTransformation = {}));
const ObjectLambdaAccessPointAliasStatus = {
    PROVISIONING: "PROVISIONING",
    READY: "READY",
};
class BucketAlreadyExists extends S3ControlServiceException {
    name = "BucketAlreadyExists";
    $fault = "client";
    constructor(opts) {
        super({
            name: "BucketAlreadyExists",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, BucketAlreadyExists.prototype);
    }
}
class BucketAlreadyOwnedByYou extends S3ControlServiceException {
    name = "BucketAlreadyOwnedByYou";
    $fault = "client";
    constructor(opts) {
        super({
            name: "BucketAlreadyOwnedByYou",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, BucketAlreadyOwnedByYou.prototype);
    }
}
const BucketCannedACL = {
    authenticated_read: "authenticated-read",
    private: "private",
    public_read: "public-read",
    public_read_write: "public-read-write",
};
const BucketLocationConstraint = {
    EU: "EU",
    ap_northeast_1: "ap-northeast-1",
    ap_south_1: "ap-south-1",
    ap_southeast_1: "ap-southeast-1",
    ap_southeast_2: "ap-southeast-2",
    cn_north_1: "cn-north-1",
    eu_central_1: "eu-central-1",
    eu_west_1: "eu-west-1",
    sa_east_1: "sa-east-1",
    us_west_1: "us-west-1",
    us_west_2: "us-west-2",
};
class BadRequestException extends S3ControlServiceException {
    name = "BadRequestException";
    $fault = "client";
    Message;
    constructor(opts) {
        super({
            name: "BadRequestException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, BadRequestException.prototype);
        this.Message = opts.Message;
    }
}
const JobManifestFieldName = {
    Bucket: "Bucket",
    Ignore: "Ignore",
    Key: "Key",
    VersionId: "VersionId",
};
const JobManifestFormat = {
    S3BatchOperations_CSV_20180820: "S3BatchOperations_CSV_20180820",
    S3InventoryReport_CSV_20161130: "S3InventoryReport_CSV_20161130",
};
exports.ObjectEncryptionFilter = void 0;
(function (ObjectEncryptionFilter) {
    ObjectEncryptionFilter.visit = (value, visitor) => {
        if (value.SSES3 !== undefined)
            return visitor.SSES3(value.SSES3);
        if (value.SSEKMS !== undefined)
            return visitor.SSEKMS(value.SSEKMS);
        if (value.DSSEKMS !== undefined)
            return visitor.DSSEKMS(value.DSSEKMS);
        if (value.SSEC !== undefined)
            return visitor.SSEC(value.SSEC);
        if (value.NOTSSE !== undefined)
            return visitor.NOTSSE(value.NOTSSE);
        return visitor._(value.$unknown[0], value.$unknown[1]);
    };
})(exports.ObjectEncryptionFilter || (exports.ObjectEncryptionFilter = {}));
const S3StorageClass = {
    DEEP_ARCHIVE: "DEEP_ARCHIVE",
    GLACIER: "GLACIER",
    GLACIER_IR: "GLACIER_IR",
    INTELLIGENT_TIERING: "INTELLIGENT_TIERING",
    ONEZONE_IA: "ONEZONE_IA",
    STANDARD: "STANDARD",
    STANDARD_IA: "STANDARD_IA",
};
const ReplicationStatus = {
    COMPLETED: "COMPLETED",
    FAILED: "FAILED",
    NONE: "NONE",
    REPLICA: "REPLICA",
};
const GeneratedManifestFormat = {
    S3InventoryReport_CSV_20211130: "S3InventoryReport_CSV_20211130",
};
exports.JobManifestGenerator = void 0;
(function (JobManifestGenerator) {
    JobManifestGenerator.visit = (value, visitor) => {
        if (value.S3JobManifestGenerator !== undefined)
            return visitor.S3JobManifestGenerator(value.S3JobManifestGenerator);
        return visitor._(value.$unknown[0], value.$unknown[1]);
    };
})(exports.JobManifestGenerator || (exports.JobManifestGenerator = {}));
const ComputeObjectChecksumAlgorithm = {
    CRC32: "CRC32",
    CRC32C: "CRC32C",
    CRC64NVME: "CRC64NVME",
    MD5: "MD5",
    SHA1: "SHA1",
    SHA256: "SHA256",
};
const ComputeObjectChecksumType = {
    COMPOSITE: "COMPOSITE",
    FULL_OBJECT: "FULL_OBJECT",
};
const S3GlacierJobTier = {
    BULK: "BULK",
    STANDARD: "STANDARD",
};
const S3GranteeTypeIdentifier = {
    CANONICAL: "id",
    EMAIL_ADDRESS: "emailAddress",
    GROUP: "uri",
};
const S3Permission = {
    FULL_CONTROL: "FULL_CONTROL",
    READ: "READ",
    READ_ACP: "READ_ACP",
    WRITE: "WRITE",
    WRITE_ACP: "WRITE_ACP",
};
const S3CannedAccessControlList = {
    AUTHENTICATED_READ: "authenticated-read",
    AWS_EXEC_READ: "aws-exec-read",
    BUCKET_OWNER_FULL_CONTROL: "bucket-owner-full-control",
    BUCKET_OWNER_READ: "bucket-owner-read",
    PRIVATE: "private",
    PUBLIC_READ: "public-read",
    PUBLIC_READ_WRITE: "public-read-write",
};
const S3ChecksumAlgorithm = {
    CRC32: "CRC32",
    CRC32C: "CRC32C",
    CRC64NVME: "CRC64NVME",
    SHA1: "SHA1",
    SHA256: "SHA256",
};
const S3MetadataDirective = {
    COPY: "COPY",
    REPLACE: "REPLACE",
};
const S3SSEAlgorithm = {
    AES256: "AES256",
    KMS: "KMS",
};
const S3ObjectLockLegalHoldStatus = {
    OFF: "OFF",
    ON: "ON",
};
const S3ObjectLockMode = {
    COMPLIANCE: "COMPLIANCE",
    GOVERNANCE: "GOVERNANCE",
};
const S3ObjectLockRetentionMode = {
    COMPLIANCE: "COMPLIANCE",
    GOVERNANCE: "GOVERNANCE",
};
const JobReportFormat = {
    Report_CSV_20180820: "Report_CSV_20180820",
};
const JobReportScope = {
    AllTasks: "AllTasks",
    FailedTasksOnly: "FailedTasksOnly",
};
class IdempotencyException extends S3ControlServiceException {
    name = "IdempotencyException";
    $fault = "client";
    Message;
    constructor(opts) {
        super({
            name: "IdempotencyException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, IdempotencyException.prototype);
        this.Message = opts.Message;
    }
}
class InternalServiceException extends S3ControlServiceException {
    name = "InternalServiceException";
    $fault = "server";
    Message;
    constructor(opts) {
        super({
            name: "InternalServiceException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, InternalServiceException.prototype);
        this.Message = opts.Message;
    }
}
class TooManyRequestsException extends S3ControlServiceException {
    name = "TooManyRequestsException";
    $fault = "client";
    Message;
    constructor(opts) {
        super({
            name: "TooManyRequestsException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, TooManyRequestsException.prototype);
        this.Message = opts.Message;
    }
}
class NotFoundException extends S3ControlServiceException {
    name = "NotFoundException";
    $fault = "client";
    Message;
    constructor(opts) {
        super({
            name: "NotFoundException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, NotFoundException.prototype);
        this.Message = opts.Message;
    }
}
const JobStatus = {
    Active: "Active",
    Cancelled: "Cancelled",
    Cancelling: "Cancelling",
    Complete: "Complete",
    Completing: "Completing",
    Failed: "Failed",
    Failing: "Failing",
    New: "New",
    Paused: "Paused",
    Pausing: "Pausing",
    Preparing: "Preparing",
    Ready: "Ready",
    Suspended: "Suspended",
};
const TransitionStorageClass = {
    DEEP_ARCHIVE: "DEEP_ARCHIVE",
    GLACIER: "GLACIER",
    INTELLIGENT_TIERING: "INTELLIGENT_TIERING",
    ONEZONE_IA: "ONEZONE_IA",
    STANDARD_IA: "STANDARD_IA",
};
const ExpirationStatus = {
    Disabled: "Disabled",
    Enabled: "Enabled",
};
const DeleteMarkerReplicationStatus = {
    Disabled: "Disabled",
    Enabled: "Enabled",
};
const MetricsStatus = {
    Disabled: "Disabled",
    Enabled: "Enabled",
};
const ReplicationTimeStatus = {
    Disabled: "Disabled",
    Enabled: "Enabled",
};
const ReplicationStorageClass = {
    DEEP_ARCHIVE: "DEEP_ARCHIVE",
    GLACIER: "GLACIER",
    GLACIER_IR: "GLACIER_IR",
    INTELLIGENT_TIERING: "INTELLIGENT_TIERING",
    ONEZONE_IA: "ONEZONE_IA",
    OUTPOSTS: "OUTPOSTS",
    REDUCED_REDUNDANCY: "REDUCED_REDUNDANCY",
    STANDARD: "STANDARD",
    STANDARD_IA: "STANDARD_IA",
};
const ExistingObjectReplicationStatus = {
    Disabled: "Disabled",
    Enabled: "Enabled",
};
const ReplicaModificationsStatus = {
    Disabled: "Disabled",
    Enabled: "Enabled",
};
const SseKmsEncryptedObjectsStatus = {
    Disabled: "Disabled",
    Enabled: "Enabled",
};
const ReplicationRuleStatus = {
    Disabled: "Disabled",
    Enabled: "Enabled",
};
const MFADeleteStatus = {
    Disabled: "Disabled",
    Enabled: "Enabled",
};
const BucketVersioningStatus = {
    Enabled: "Enabled",
    Suspended: "Suspended",
};
const Privilege = {
    Default: "Default",
    Minimal: "Minimal",
};
const MultiRegionAccessPointStatus = {
    CREATING: "CREATING",
    DELETING: "DELETING",
    INCONSISTENT_ACROSS_REGIONS: "INCONSISTENT_ACROSS_REGIONS",
    PARTIALLY_CREATED: "PARTIALLY_CREATED",
    PARTIALLY_DELETED: "PARTIALLY_DELETED",
    READY: "READY",
};
class NoSuchPublicAccessBlockConfiguration extends S3ControlServiceException {
    name = "NoSuchPublicAccessBlockConfiguration";
    $fault = "client";
    Message;
    constructor(opts) {
        super({
            name: "NoSuchPublicAccessBlockConfiguration",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, NoSuchPublicAccessBlockConfiguration.prototype);
        this.Message = opts.Message;
    }
}
const Format = {
    CSV: "CSV",
    Parquet: "Parquet",
};
const OutputSchemaVersion = {
    V_1: "V_1",
};
const CredentialsFilterSensitiveLog = (obj) => ({
    ...obj,
    ...(obj.AccessKeyId && { AccessKeyId: smithyClient.SENSITIVE_STRING }),
    ...(obj.SecretAccessKey && { SecretAccessKey: smithyClient.SENSITIVE_STRING }),
    ...(obj.SessionToken && { SessionToken: smithyClient.SENSITIVE_STRING }),
});
const GetDataAccessResultFilterSensitiveLog = (obj) => ({
    ...obj,
    ...(obj.Credentials && { Credentials: smithyClient.SENSITIVE_STRING }),
});

class InvalidNextTokenException extends S3ControlServiceException {
    name = "InvalidNextTokenException";
    $fault = "client";
    Message;
    constructor(opts) {
        super({
            name: "InvalidNextTokenException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidNextTokenException.prototype);
        this.Message = opts.Message;
    }
}
class InvalidRequestException extends S3ControlServiceException {
    name = "InvalidRequestException";
    $fault = "client";
    Message;
    constructor(opts) {
        super({
            name: "InvalidRequestException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidRequestException.prototype);
        this.Message = opts.Message;
    }
}
const OperationName = {
    LambdaInvoke: "LambdaInvoke",
    S3ComputeObjectChecksum: "S3ComputeObjectChecksum",
    S3DeleteObjectTagging: "S3DeleteObjectTagging",
    S3InitiateRestoreObject: "S3InitiateRestoreObject",
    S3PutObjectAcl: "S3PutObjectAcl",
    S3PutObjectCopy: "S3PutObjectCopy",
    S3PutObjectLegalHold: "S3PutObjectLegalHold",
    S3PutObjectRetention: "S3PutObjectRetention",
    S3PutObjectTagging: "S3PutObjectTagging",
    S3ReplicateObject: "S3ReplicateObject",
};
const MFADelete = {
    Disabled: "Disabled",
    Enabled: "Enabled",
};
class TooManyTagsException extends S3ControlServiceException {
    name = "TooManyTagsException";
    $fault = "client";
    Message;
    constructor(opts) {
        super({
            name: "TooManyTagsException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, TooManyTagsException.prototype);
        this.Message = opts.Message;
    }
}
class JobStatusException extends S3ControlServiceException {
    name = "JobStatusException";
    $fault = "client";
    Message;
    constructor(opts) {
        super({
            name: "JobStatusException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, JobStatusException.prototype);
        this.Message = opts.Message;
    }
}
const RequestedJobStatus = {
    Cancelled: "Cancelled",
    Ready: "Ready",
};

const se_AssociateAccessGrantsIdentityCenterCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        "content-type": "application/xml",
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accessgrantsinstance/identitycenter");
    let body;
    body = _ve;
    const bn = new xmlBuilder.XmlNode(_AAGICR);
    bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
    bn.cc(input, _ICA);
    body += bn.toString();
    b.m("POST").h(headers).b(body);
    return b.build();
};
const se_CreateAccessGrantCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        "content-type": "application/xml",
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accessgrantsinstance/grant");
    let body;
    body = _ve;
    const bn = new xmlBuilder.XmlNode(_CAGR);
    bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
    if (input[_AGLC] != null) {
        bn.c(se_AccessGrantsLocationConfiguration(input[_AGLC]).n(_AGLC));
    }
    bn.cc(input, _AGLI);
    if (input[_AA] != null) {
        bn.c(xmlBuilder.XmlNode.of(_ICAA, input[_AA]).n(_AA));
    }
    if (input[_G] != null) {
        bn.c(se_Grantee(input[_G]).n(_G));
    }
    bn.cc(input, _P);
    bn.cc(input, _SPT);
    bn.lc(input, "Tags", "Tags", () => se_TagList(input[_T]));
    body += bn.toString();
    b.m("POST").h(headers).b(body);
    return b.build();
};
const se_CreateAccessGrantsInstanceCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        "content-type": "application/xml",
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accessgrantsinstance");
    let body;
    body = _ve;
    const bn = new xmlBuilder.XmlNode(_CAGIR);
    bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
    bn.cc(input, _ICA);
    bn.lc(input, "Tags", "Tags", () => se_TagList(input[_T]));
    body += bn.toString();
    b.m("POST").h(headers).b(body);
    return b.build();
};
const se_CreateAccessGrantsLocationCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        "content-type": "application/xml",
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accessgrantsinstance/location");
    let body;
    body = _ve;
    const bn = new xmlBuilder.XmlNode(_CAGLR);
    bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
    bn.cc(input, _IAMRA);
    if (input[_LS] != null) {
        bn.c(xmlBuilder.XmlNode.of(_SP, input[_LS]).n(_LS));
    }
    bn.lc(input, "Tags", "Tags", () => se_TagList(input[_T]));
    body += bn.toString();
    b.m("POST").h(headers).b(body);
    return b.build();
};
const se_CreateAccessPointCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        "content-type": "application/xml",
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accesspoint/{Name}");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    body = _ve;
    const bn = new xmlBuilder.XmlNode(_CAPR);
    bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
    if (input[_B] != null) {
        bn.c(xmlBuilder.XmlNode.of(_BN, input[_B]).n(_B));
    }
    if (input[_BAI] != null) {
        bn.c(xmlBuilder.XmlNode.of(_AI, input[_BAI]).n(_BAI));
    }
    if (input[_PABC] != null) {
        bn.c(se_PublicAccessBlockConfiguration(input[_PABC]).n(_PABC));
    }
    if (input[_S] != null) {
        bn.c(se_Scope(input[_S]).n(_S));
    }
    bn.lc(input, "Tags", "Tags", () => se_TagList(input[_T]));
    if (input[_VC] != null) {
        bn.c(se_VpcConfiguration(input[_VC]).n(_VC));
    }
    body += bn.toString();
    b.m("PUT").h(headers).b(body);
    return b.build();
};
const se_CreateAccessPointForObjectLambdaCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        "content-type": "application/xml",
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accesspointforobjectlambda/{Name}");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    body = _ve;
    const bn = new xmlBuilder.XmlNode(_CAPFOLR);
    bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
    if (input[_C] != null) {
        bn.c(se_ObjectLambdaConfiguration(input[_C]).n(_C));
    }
    body += bn.toString();
    b.m("PUT").h(headers).b(body);
    return b.build();
};
const se_CreateBucketCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        "content-type": "application/xml",
        [_xaa]: input[_ACL],
        [_xagfc]: input[_GFC],
        [_xagr]: input[_GR],
        [_xagra]: input[_GRACP],
        [_xagw]: input[_GW],
        [_xagwa]: input[_GWACP],
        [_xabole]: [() => smithyClient.isSerializableHeaderValue(input[_OLEFB]), () => input[_OLEFB].toString()],
        [_xaoi]: input[_OI],
    });
    b.bp("/v20180820/bucket/{Bucket}");
    b.p("Bucket", () => input.Bucket, "{Bucket}", false);
    let body;
    let contents;
    if (input.CreateBucketConfiguration !== undefined) {
        contents = se_CreateBucketConfiguration(input.CreateBucketConfiguration);
        body = _ve;
        contents.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
        body += contents.toString();
    }
    b.m("PUT").h(headers).b(body);
    return b.build();
};
const se_CreateJobCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        "content-type": "application/xml",
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/jobs");
    let body;
    body = _ve;
    const bn = new xmlBuilder.XmlNode(_CJR);
    bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
    if (input[_CRT] === undefined) {
        input[_CRT] = uuid.v4();
    }
    if (input[_CRT] != null) {
        bn.c(xmlBuilder.XmlNode.of(_NEMLS, input[_CRT]).n(_CRT));
    }
    if (input[_CR] != null) {
        bn.c(xmlBuilder.XmlNode.of(_CR, String(input[_CR])).n(_CR));
    }
    if (input[_D] != null) {
        bn.c(xmlBuilder.XmlNode.of(_NEMLSo, input[_D]).n(_D));
    }
    if (input[_M] != null) {
        bn.c(se_JobManifest(input[_M]).n(_M));
    }
    if (input[_MG] != null) {
        bn.c(se_JobManifestGenerator(input[_MG]).n(_MG));
    }
    if (input[_O] != null) {
        bn.c(se_JobOperation(input[_O]).n(_O));
    }
    if (input[_Pr] != null) {
        bn.c(xmlBuilder.XmlNode.of(_JP, String(input[_Pr])).n(_Pr));
    }
    if (input[_R] != null) {
        bn.c(se_JobReport(input[_R]).n(_R));
    }
    if (input[_RA] != null) {
        bn.c(xmlBuilder.XmlNode.of(_IAMRA, input[_RA]).n(_RA));
    }
    bn.lc(input, "Tags", "Tags", () => se_S3TagSet(input[_T]));
    body += bn.toString();
    b.m("POST").h(headers).b(body);
    return b.build();
};
const se_CreateMultiRegionAccessPointCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        "content-type": "application/xml",
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/async-requests/mrap/create");
    let body;
    body = _ve;
    const bn = new xmlBuilder.XmlNode(_CMRAPR);
    bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
    if (input[_CT] === undefined) {
        input[_CT] = uuid.v4();
    }
    if (input[_CT] != null) {
        bn.c(xmlBuilder.XmlNode.of(_MRAPCT, input[_CT]).n(_CT));
    }
    if (input[_De] != null) {
        bn.c(se_CreateMultiRegionAccessPointInput(input[_De]).n(_De));
    }
    body += bn.toString();
    b.m("POST").h(headers).b(body);
    return b.build();
};
const se_CreateStorageLensGroupCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        "content-type": "application/xml",
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/storagelensgroup");
    let body;
    body = _ve;
    const bn = new xmlBuilder.XmlNode(_CSLGR);
    bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
    if (input[_SLG] != null) {
        bn.c(se_StorageLensGroup(input[_SLG]).n(_SLG));
    }
    bn.lc(input, "Tags", "Tags", () => se_TagList(input[_T]));
    body += bn.toString();
    b.m("POST").h(headers).b(body);
    return b.build();
};
const se_DeleteAccessGrantCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accessgrantsinstance/grant/{AccessGrantId}");
    b.p("AccessGrantId", () => input.AccessGrantId, "{AccessGrantId}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteAccessGrantsInstanceCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accessgrantsinstance");
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteAccessGrantsInstanceResourcePolicyCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accessgrantsinstance/resourcepolicy");
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteAccessGrantsLocationCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accessgrantsinstance/location/{AccessGrantsLocationId}");
    b.p("AccessGrantsLocationId", () => input.AccessGrantsLocationId, "{AccessGrantsLocationId}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteAccessPointCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accesspoint/{Name}");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteAccessPointForObjectLambdaCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accesspointforobjectlambda/{Name}");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteAccessPointPolicyCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accesspoint/{Name}/policy");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteAccessPointPolicyForObjectLambdaCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accesspointforobjectlambda/{Name}/policy");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteAccessPointScopeCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accesspoint/{Name}/scope");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteBucketCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/bucket/{Bucket}");
    b.p("Bucket", () => input.Bucket, "{Bucket}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteBucketLifecycleConfigurationCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/bucket/{Bucket}/lifecycleconfiguration");
    b.p("Bucket", () => input.Bucket, "{Bucket}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteBucketPolicyCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/bucket/{Bucket}/policy");
    b.p("Bucket", () => input.Bucket, "{Bucket}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteBucketReplicationCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/bucket/{Bucket}/replication");
    b.p("Bucket", () => input.Bucket, "{Bucket}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteBucketTaggingCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/bucket/{Bucket}/tagging");
    b.p("Bucket", () => input.Bucket, "{Bucket}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteJobTaggingCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/jobs/{JobId}/tagging");
    b.p("JobId", () => input.JobId, "{JobId}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteMultiRegionAccessPointCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        "content-type": "application/xml",
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/async-requests/mrap/delete");
    let body;
    body = _ve;
    const bn = new xmlBuilder.XmlNode(_DMRAPR);
    bn.a("xmlns", "http://awss3control.amazonaws.com/doc/2018-08-20/");
    if (input[_CT] === undefined) {
        input[_CT] = uuid.v4();
    }
    if (input[_CT] != null) {
        bn.c(xmlBuilder.XmlNode.of(_MRAPCT, input[_CT]).n(_CT));
    }
    if (input[_De] != null) {
        bn.c(se_DeleteMultiRegionAccessPointInput(input[_De]).n(_De));
    }
    body += bn.toString();
    b.m("POST").h(headers).b(body);
    return b.build();
};
const se_DeletePublicAccessBlockCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/configuration/publicAccessBlock");
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteStorageLensConfigurationCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/storagelens/{ConfigId}");
    b.p("ConfigId", () => input.ConfigId, "{ConfigId}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteStorageLensConfigurationTaggingCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/storagelens/{ConfigId}/tagging");
    b.p("ConfigId", () => input.ConfigId, "{ConfigId}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DeleteStorageLensGroupCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/storagelensgroup/{Name}");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_DescribeJobCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/jobs/{JobId}");
    b.p("JobId", () => input.JobId, "{JobId}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_DescribeMultiRegionAccessPointOperationCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/async-requests/mrap/{RequestTokenARN+}");
    b.p("RequestTokenARN", () => input.RequestTokenARN, "{RequestTokenARN+}", true);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_DissociateAccessGrantsIdentityCenterCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accessgrantsinstance/identitycenter");
    let body;
    b.m("DELETE").h(headers).b(body);
    return b.build();
};
const se_GetAccessGrantCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accessgrantsinstance/grant/{AccessGrantId}");
    b.p("AccessGrantId", () => input.AccessGrantId, "{AccessGrantId}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetAccessGrantsInstanceCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accessgrantsinstance");
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetAccessGrantsInstanceForPrefixCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accessgrantsinstance/prefix");
    const query = smithyClient.map({
        [_s]: [, smithyClient.expectNonNull(input[_SP], `S3Prefix`)],
    });
    let body;
    b.m("GET").h(headers).q(query).b(body);
    return b.build();
};
const se_GetAccessGrantsInstanceResourcePolicyCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accessgrantsinstance/resourcepolicy");
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetAccessGrantsLocationCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accessgrantsinstance/location/{AccessGrantsLocationId}");
    b.p("AccessGrantsLocationId", () => input.AccessGrantsLocationId, "{AccessGrantsLocationId}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetAccessPointCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accesspoint/{Name}");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetAccessPointConfigurationForObjectLambdaCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accesspointforobjectlambda/{Name}/configuration");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetAccessPointForObjectLambdaCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accesspointforobjectlambda/{Name}");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetAccessPointPolicyCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accesspoint/{Name}/policy");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetAccessPointPolicyForObjectLambdaCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accesspointforobjectlambda/{Name}/policy");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetAccessPointPolicyStatusCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accesspoint/{Name}/policyStatus");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetAccessPointPolicyStatusForObjectLambdaCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accesspointforobjectlambda/{Name}/policyStatus");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetAccessPointScopeCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accesspoint/{Name}/scope");
    b.p("Name", () => input.Name, "{Name}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetBucketCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/bucket/{Bucket}");
    b.p("Bucket", () => input.Bucket, "{Bucket}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetBucketLifecycleConfigurationCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/bucket/{Bucket}/lifecycleconfiguration");
    b.p("Bucket", () => input.Bucket, "{Bucket}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetBucketPolicyCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/bucket/{Bucket}/policy");
    b.p("Bucket", () => input.Bucket, "{Bucket}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetBucketReplicationCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/bucket/{Bucket}/replication");
    b.p("Bucket", () => input.Bucket, "{Bucket}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetBucketTaggingCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/bucket/{Bucket}/tagging");
    b.p("Bucket", () => input.Bucket, "{Bucket}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetBucketVersioningCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/bucket/{Bucket}/versioning");
    b.p("Bucket", () => input.Bucket, "{Bucket}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetDataAccessCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/accessgrantsinstance/dataaccess");
    const query = smithyClient.map({
        [_t]: [, smithyClient.expectNonNull(input[_Ta], `Target`)],
        [_p]: [, smithyClient.expectNonNull(input[_P], `Permission`)],
        [_dS]: [() => input.DurationSeconds !== void 0, () => input[_DS].toString()],
        [_pr]: [, input[_Pri]],
        [_tT]: [, input[_TT]],
    });
    let body;
    b.m("GET").h(headers).q(query).b(body);
    return b.build();
};
const se_GetJobTaggingCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/jobs/{JobId}/tagging");
    b.p("JobId", () => input.JobId, "{JobId}", false);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetMultiRegionAccessPointCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/mrap/instances/{Name+}");
    b.p("Name", () => input.Name, "{Name+}", true);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetMultiRegionAccessPointPolicyCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20180820/mrap/instances/{Name+}/policy");
    b.p("Name", () => input.Name, "{Name+}", true);
    let body;
    b.m("GET").h(headers).b(body);
    return b.build();
};
const se_GetMultiRegionAccessPointPolicyStatusCommand = async (input, context) => {
    const b = core.requestBuilder(input, context);
    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
        [_xaai]: input[_AI],
    });
    b.bp("/v20