'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 middlewareSdkSqs = require('@aws-sdk/middleware-sdk-sqs');
var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
var configResolver = require('@smithy/config-resolver');
var core = require('@smithy/core');
var schema = require('@smithy/core/schema');
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');

const resolveClientEndpointParameters = (options) => {
    return Object.assign(options, {
        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
        useFipsEndpoint: options.useFipsEndpoint ?? false,
        defaultSigningName: "sqs",
    });
};
const commonParams = {
    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 SQSClient 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 = middlewareSdkSqs.resolveQueueUrlConfig(_config_6);
        const _config_8 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_7);
        const _config_9 = resolveRuntimeExtensions(_config_8, configuration?.extensions || []);
        this.config = _config_9;
        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
        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(middlewareSdkSqs.getQueueUrlPlugin(this.config));
        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultSQSHttpAuthSchemeParametersProvider,
            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
                "aws.auth#sigv4": config.credentials,
            }),
        }));
        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
    }
    destroy() {
        super.destroy();
    }
}

let SQSServiceException$1 = class SQSServiceException extends smithyClient.ServiceException {
    constructor(options) {
        super(options);
        Object.setPrototypeOf(this, SQSServiceException.prototype);
    }
};

let InvalidAddress$1 = class InvalidAddress extends SQSServiceException$1 {
    name = "InvalidAddress";
    $fault = "client";
    constructor(opts) {
        super({
            name: "InvalidAddress",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidAddress.prototype);
    }
};
let InvalidSecurity$1 = class InvalidSecurity extends SQSServiceException$1 {
    name = "InvalidSecurity";
    $fault = "client";
    constructor(opts) {
        super({
            name: "InvalidSecurity",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidSecurity.prototype);
    }
};
let OverLimit$1 = class OverLimit extends SQSServiceException$1 {
    name = "OverLimit";
    $fault = "client";
    constructor(opts) {
        super({
            name: "OverLimit",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, OverLimit.prototype);
    }
};
let QueueDoesNotExist$1 = class QueueDoesNotExist extends SQSServiceException$1 {
    name = "QueueDoesNotExist";
    $fault = "client";
    constructor(opts) {
        super({
            name: "QueueDoesNotExist",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, QueueDoesNotExist.prototype);
    }
};
let RequestThrottled$1 = class RequestThrottled extends SQSServiceException$1 {
    name = "RequestThrottled";
    $fault = "client";
    constructor(opts) {
        super({
            name: "RequestThrottled",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, RequestThrottled.prototype);
    }
};
let UnsupportedOperation$1 = class UnsupportedOperation extends SQSServiceException$1 {
    name = "UnsupportedOperation";
    $fault = "client";
    constructor(opts) {
        super({
            name: "UnsupportedOperation",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UnsupportedOperation.prototype);
    }
};
let ResourceNotFoundException$1 = class ResourceNotFoundException extends SQSServiceException$1 {
    name = "ResourceNotFoundException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "ResourceNotFoundException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
    }
};
let MessageNotInflight$1 = class MessageNotInflight extends SQSServiceException$1 {
    name = "MessageNotInflight";
    $fault = "client";
    constructor(opts) {
        super({
            name: "MessageNotInflight",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, MessageNotInflight.prototype);
    }
};
let ReceiptHandleIsInvalid$1 = class ReceiptHandleIsInvalid extends SQSServiceException$1 {
    name = "ReceiptHandleIsInvalid";
    $fault = "client";
    constructor(opts) {
        super({
            name: "ReceiptHandleIsInvalid",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ReceiptHandleIsInvalid.prototype);
    }
};
let BatchEntryIdsNotDistinct$1 = class BatchEntryIdsNotDistinct extends SQSServiceException$1 {
    name = "BatchEntryIdsNotDistinct";
    $fault = "client";
    constructor(opts) {
        super({
            name: "BatchEntryIdsNotDistinct",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, BatchEntryIdsNotDistinct.prototype);
    }
};
let EmptyBatchRequest$1 = class EmptyBatchRequest extends SQSServiceException$1 {
    name = "EmptyBatchRequest";
    $fault = "client";
    constructor(opts) {
        super({
            name: "EmptyBatchRequest",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, EmptyBatchRequest.prototype);
    }
};
let InvalidBatchEntryId$1 = class InvalidBatchEntryId extends SQSServiceException$1 {
    name = "InvalidBatchEntryId";
    $fault = "client";
    constructor(opts) {
        super({
            name: "InvalidBatchEntryId",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidBatchEntryId.prototype);
    }
};
let TooManyEntriesInBatchRequest$1 = class TooManyEntriesInBatchRequest extends SQSServiceException$1 {
    name = "TooManyEntriesInBatchRequest";
    $fault = "client";
    constructor(opts) {
        super({
            name: "TooManyEntriesInBatchRequest",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, TooManyEntriesInBatchRequest.prototype);
    }
};
const QueueAttributeName = {
    All: "All",
    ApproximateNumberOfMessages: "ApproximateNumberOfMessages",
    ApproximateNumberOfMessagesDelayed: "ApproximateNumberOfMessagesDelayed",
    ApproximateNumberOfMessagesNotVisible: "ApproximateNumberOfMessagesNotVisible",
    ContentBasedDeduplication: "ContentBasedDeduplication",
    CreatedTimestamp: "CreatedTimestamp",
    DeduplicationScope: "DeduplicationScope",
    DelaySeconds: "DelaySeconds",
    FifoQueue: "FifoQueue",
    FifoThroughputLimit: "FifoThroughputLimit",
    KmsDataKeyReusePeriodSeconds: "KmsDataKeyReusePeriodSeconds",
    KmsMasterKeyId: "KmsMasterKeyId",
    LastModifiedTimestamp: "LastModifiedTimestamp",
    MaximumMessageSize: "MaximumMessageSize",
    MessageRetentionPeriod: "MessageRetentionPeriod",
    Policy: "Policy",
    QueueArn: "QueueArn",
    ReceiveMessageWaitTimeSeconds: "ReceiveMessageWaitTimeSeconds",
    RedriveAllowPolicy: "RedriveAllowPolicy",
    RedrivePolicy: "RedrivePolicy",
    SqsManagedSseEnabled: "SqsManagedSseEnabled",
    VisibilityTimeout: "VisibilityTimeout",
};
let InvalidAttributeName$1 = class InvalidAttributeName extends SQSServiceException$1 {
    name = "InvalidAttributeName";
    $fault = "client";
    constructor(opts) {
        super({
            name: "InvalidAttributeName",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidAttributeName.prototype);
    }
};
let InvalidAttributeValue$1 = class InvalidAttributeValue extends SQSServiceException$1 {
    name = "InvalidAttributeValue";
    $fault = "client";
    constructor(opts) {
        super({
            name: "InvalidAttributeValue",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidAttributeValue.prototype);
    }
};
let QueueDeletedRecently$1 = class QueueDeletedRecently extends SQSServiceException$1 {
    name = "QueueDeletedRecently";
    $fault = "client";
    constructor(opts) {
        super({
            name: "QueueDeletedRecently",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, QueueDeletedRecently.prototype);
    }
};
let QueueNameExists$1 = class QueueNameExists extends SQSServiceException$1 {
    name = "QueueNameExists";
    $fault = "client";
    constructor(opts) {
        super({
            name: "QueueNameExists",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, QueueNameExists.prototype);
    }
};
let InvalidIdFormat$1 = class InvalidIdFormat extends SQSServiceException$1 {
    name = "InvalidIdFormat";
    $fault = "client";
    constructor(opts) {
        super({
            name: "InvalidIdFormat",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidIdFormat.prototype);
    }
};
let PurgeQueueInProgress$1 = class PurgeQueueInProgress extends SQSServiceException$1 {
    name = "PurgeQueueInProgress";
    $fault = "client";
    constructor(opts) {
        super({
            name: "PurgeQueueInProgress",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, PurgeQueueInProgress.prototype);
    }
};
let KmsAccessDenied$1 = class KmsAccessDenied extends SQSServiceException$1 {
    name = "KmsAccessDenied";
    $fault = "client";
    constructor(opts) {
        super({
            name: "KmsAccessDenied",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, KmsAccessDenied.prototype);
    }
};
let KmsDisabled$1 = class KmsDisabled extends SQSServiceException$1 {
    name = "KmsDisabled";
    $fault = "client";
    constructor(opts) {
        super({
            name: "KmsDisabled",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, KmsDisabled.prototype);
    }
};
let KmsInvalidKeyUsage$1 = class KmsInvalidKeyUsage extends SQSServiceException$1 {
    name = "KmsInvalidKeyUsage";
    $fault = "client";
    constructor(opts) {
        super({
            name: "KmsInvalidKeyUsage",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, KmsInvalidKeyUsage.prototype);
    }
};
let KmsInvalidState$1 = class KmsInvalidState extends SQSServiceException$1 {
    name = "KmsInvalidState";
    $fault = "client";
    constructor(opts) {
        super({
            name: "KmsInvalidState",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, KmsInvalidState.prototype);
    }
};
let KmsNotFound$1 = class KmsNotFound extends SQSServiceException$1 {
    name = "KmsNotFound";
    $fault = "client";
    constructor(opts) {
        super({
            name: "KmsNotFound",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, KmsNotFound.prototype);
    }
};
let KmsOptInRequired$1 = class KmsOptInRequired extends SQSServiceException$1 {
    name = "KmsOptInRequired";
    $fault = "client";
    constructor(opts) {
        super({
            name: "KmsOptInRequired",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, KmsOptInRequired.prototype);
    }
};
let KmsThrottled$1 = class KmsThrottled extends SQSServiceException$1 {
    name = "KmsThrottled";
    $fault = "client";
    constructor(opts) {
        super({
            name: "KmsThrottled",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, KmsThrottled.prototype);
    }
};
const MessageSystemAttributeName = {
    AWSTraceHeader: "AWSTraceHeader",
    All: "All",
    ApproximateFirstReceiveTimestamp: "ApproximateFirstReceiveTimestamp",
    ApproximateReceiveCount: "ApproximateReceiveCount",
    DeadLetterQueueSourceArn: "DeadLetterQueueSourceArn",
    MessageDeduplicationId: "MessageDeduplicationId",
    MessageGroupId: "MessageGroupId",
    SenderId: "SenderId",
    SentTimestamp: "SentTimestamp",
    SequenceNumber: "SequenceNumber",
};
let InvalidMessageContents$1 = class InvalidMessageContents extends SQSServiceException$1 {
    name = "InvalidMessageContents";
    $fault = "client";
    constructor(opts) {
        super({
            name: "InvalidMessageContents",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidMessageContents.prototype);
    }
};
const MessageSystemAttributeNameForSends = {
    AWSTraceHeader: "AWSTraceHeader",
};
let BatchRequestTooLong$1 = class BatchRequestTooLong extends SQSServiceException$1 {
    name = "BatchRequestTooLong";
    $fault = "client";
    constructor(opts) {
        super({
            name: "BatchRequestTooLong",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, BatchRequestTooLong.prototype);
    }
};

const _A = "Actions";
const _AN = "ActionName";
const _ANOMM = "ApproximateNumberOfMessagesMoved";
const _ANOMTM = "ApproximateNumberOfMessagesToMove";
const _ANt = "AttributeNames";
const _ANtt = "AttributeName";
const _AP = "AddPermission";
const _APR = "AddPermissionRequest";
const _AWSAI = "AWSAccountIds";
const _AWSAIc = "AWSAccountId";
const _At = "Attributes";
const _Att = "Attribute";
const _B = "Body";
const _BEIND = "BatchEntryIdsNotDistinct";
const _BL = "BinaryList";
const _BLV = "BinaryListValues";
const _BLVi = "BinaryListValue";
const _BREE = "BatchResultErrorEntry";
const _BREEL = "BatchResultErrorEntryList";
const _BRTL = "BatchRequestTooLong";
const _BV = "BinaryValue";
const _C = "Code";
const _CMMT = "CancelMessageMoveTask";
const _CMMTR = "CancelMessageMoveTaskRequest";
const _CMMTRa = "CancelMessageMoveTaskResult";
const _CMV = "ChangeMessageVisibility";
const _CMVB = "ChangeMessageVisibilityBatch";
const _CMVBR = "ChangeMessageVisibilityBatchRequest";
const _CMVBRE = "ChangeMessageVisibilityBatchRequestEntry";
const _CMVBREL = "ChangeMessageVisibilityBatchRequestEntryList";
const _CMVBRELh = "ChangeMessageVisibilityBatchResultEntryList";
const _CMVBREh = "ChangeMessageVisibilityBatchResultEntry";
const _CMVBRh = "ChangeMessageVisibilityBatchResult";
const _CMVR = "ChangeMessageVisibilityRequest";
const _CQ = "CreateQueue";
const _CQR = "CreateQueueRequest";
const _CQRr = "CreateQueueResult";
const _DA = "DestinationArn";
const _DM = "DeleteMessage";
const _DMB = "DeleteMessageBatch";
const _DMBR = "DeleteMessageBatchRequest";
const _DMBRE = "DeleteMessageBatchRequestEntry";
const _DMBREL = "DeleteMessageBatchRequestEntryList";
const _DMBRELe = "DeleteMessageBatchResultEntryList";
const _DMBREe = "DeleteMessageBatchResultEntry";
const _DMBRe = "DeleteMessageBatchResult";
const _DMR = "DeleteMessageRequest";
const _DQ = "DeleteQueue";
const _DQR = "DeleteQueueRequest";
const _DS = "DelaySeconds";
const _DT = "DataType";
const _E = "Entries";
const _EBR = "EmptyBatchRequest";
const _F = "Failed";
const _FR = "FailureReason";
const _GQA = "GetQueueAttributes";
const _GQAR = "GetQueueAttributesRequest";
const _GQARe = "GetQueueAttributesResult";
const _GQU = "GetQueueUrl";
const _GQUR = "GetQueueUrlRequest";
const _GQURe = "GetQueueUrlResult";
const _I = "Id";
const _IA = "InvalidAddress";
const _IAN = "InvalidAttributeName";
const _IAV = "InvalidAttributeValue";
const _IBEI = "InvalidBatchEntryId";
const _IIF = "InvalidIdFormat";
const _IMC = "InvalidMessageContents";
const _IS = "InvalidSecurity";
const _K = "Key";
const _KAD = "KmsAccessDenied";
const _KD = "KmsDisabled";
const _KIKU = "KmsInvalidKeyUsage";
const _KIS = "KmsInvalidState";
const _KNF = "KmsNotFound";
const _KOIR = "KmsOptInRequired";
const _KT = "KmsThrottled";
const _L = "Label";
const _LDLSQ = "ListDeadLetterSourceQueues";
const _LDLSQR = "ListDeadLetterSourceQueuesRequest";
const _LDLSQRi = "ListDeadLetterSourceQueuesResult";
const _LMMT = "ListMessageMoveTasks";
const _LMMTR = "ListMessageMoveTasksRequest";
const _LMMTRE = "ListMessageMoveTasksResultEntry";
const _LMMTREL = "ListMessageMoveTasksResultEntryList";
const _LMMTRi = "ListMessageMoveTasksResult";
const _LQ = "ListQueues";
const _LQR = "ListQueuesRequest";
const _LQRi = "ListQueuesResult";
const _LQT = "ListQueueTags";
const _LQTR = "ListQueueTagsRequest";
const _LQTRi = "ListQueueTagsResult";
const _M = "Message";
const _MA = "MessageAttributes";
const _MAN = "MessageAttributeNames";
const _MANe = "MessageAttributeName";
const _MAV = "MessageAttributeValue";
const _MAe = "MessageAttribute";
const _MB = "MessageBody";
const _MBAM = "MessageBodyAttributeMap";
const _MBSAM = "MessageBodySystemAttributeMap";
const _MDI = "MessageDeduplicationId";
const _MDOB = "MD5OfBody";
const _MDOMA = "MD5OfMessageAttributes";
const _MDOMB = "MD5OfMessageBody";
const _MDOMSA = "MD5OfMessageSystemAttributes";
const _MGI = "MessageGroupId";
const _MI = "MessageId";
const _ML = "MessageList";
const _MNI = "MessageNotInflight";
const _MNOM = "MaxNumberOfMessages";
const _MNOMPS = "MaxNumberOfMessagesPerSecond";
const _MR = "MaxResults";
const _MSA = "MessageSystemAttributes";
const _MSAM = "MessageSystemAttributeMap";
const _MSAN = "MessageSystemAttributeNames";
const _MSAV = "MessageSystemAttributeValue";
const _MSAe = "MessageSystemAttribute";
const _Me = "Messages";
const _N = "Name";
const _NT = "NextToken";
const _OL = "OverLimit";
const _PQ = "PurgeQueue";
const _PQIP = "PurgeQueueInProgress";
const _PQR = "PurgeQueueRequest";
const _QAM = "QueueAttributeMap";
const _QDNE = "QueueDoesNotExist";
const _QDR = "QueueDeletedRecently";
const _QN = "QueueName";
const _QNE = "QueueNameExists";
const _QNP = "QueueNamePrefix";
const _QOAWSAI = "QueueOwnerAWSAccountId";
const _QU = "QueueUrl";
const _QUu = "QueueUrls";
const _R = "Results";
const _RH = "ReceiptHandle";
const _RHII = "ReceiptHandleIsInvalid";
const _RM = "ReceiveMessage";
const _RMR = "ReceiveMessageRequest";
const _RMRe = "ReceiveMessageResult";
const _RNFE = "ResourceNotFoundException";
const _RP = "RemovePermission";
const _RPR = "RemovePermissionRequest";
const _RRAI = "ReceiveRequestAttemptId";
const _RT = "RequestThrottled";
const _S = "Successful";
const _SA = "SourceArn";
const _SF = "SenderFault";
const _SL = "StringList";
const _SLV = "StringListValues";
const _SLVt = "StringListValue";
const _SM = "SendMessage";
const _SMB = "SendMessageBatch";
const _SMBR = "SendMessageBatchRequest";
const _SMBRE = "SendMessageBatchRequestEntry";
const _SMBREL = "SendMessageBatchRequestEntryList";
const _SMBRELe = "SendMessageBatchResultEntryList";
const _SMBREe = "SendMessageBatchResultEntry";
const _SMBRe = "SendMessageBatchResult";
const _SMMT = "StartMessageMoveTask";
const _SMMTR = "StartMessageMoveTaskRequest";
const _SMMTRt = "StartMessageMoveTaskResult";
const _SMR = "SendMessageRequest";
const _SMRe = "SendMessageResult";
const _SN = "SequenceNumber";
const _SQA = "SetQueueAttributes";
const _SQAR = "SetQueueAttributesRequest";
const _ST = "StartedTimestamp";
const _SV = "StringValue";
const _St = "Status";
const _T = "Tag";
const _TH = "TaskHandle";
const _TK = "TagKeys";
const _TKa = "TagKey";
const _TM = "TagMap";
const _TMEIBR = "TooManyEntriesInBatchRequest";
const _TQ = "TagQueue";
const _TQR = "TagQueueRequest";
const _Ta = "Tags";
const _UO = "UnsupportedOperation";
const _UQ = "UntagQueue";
const _UQR = "UntagQueueRequest";
const _V = "Value";
const _VT = "VisibilityTimeout";
const _WTS = "WaitTimeSeconds";
const _aQE = "awsQueryError";
const _c = "client";
const _e = "error";
const _hE = "httpError";
const _m = "message";
const _qU = "queueUrls";
const _s = "smithy.ts.sdk.synthetic.com.amazonaws.sqs";
const _t = "tags";
const _xF = "xmlFlattened";
const _xN = "xmlName";
const n0 = "com.amazonaws.sqs";
var AddPermissionRequest = [
    3,
    n0,
    _APR,
    0,
    [_QU, _L, _AWSAI, _A],
    [
        0,
        0,
        [
            64 | 0,
            {
                [_xN]: _AWSAIc,
                [_xF]: 1,
            },
        ],
        [
            64 | 0,
            {
                [_xN]: _AN,
                [_xF]: 1,
            },
        ],
    ],
];
var BatchEntryIdsNotDistinct = [
    -3,
    n0,
    _BEIND,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`AWS.SimpleQueueService.BatchEntryIdsNotDistinct`, 400],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(BatchEntryIdsNotDistinct, BatchEntryIdsNotDistinct$1);
var BatchRequestTooLong = [
    -3,
    n0,
    _BRTL,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`AWS.SimpleQueueService.BatchRequestTooLong`, 400],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(BatchRequestTooLong, BatchRequestTooLong$1);
var BatchResultErrorEntry = [3, n0, _BREE, 0, [_I, _SF, _C, _M], [0, 2, 0, 0]];
var CancelMessageMoveTaskRequest = [3, n0, _CMMTR, 0, [_TH], [0]];
var CancelMessageMoveTaskResult = [3, n0, _CMMTRa, 0, [_ANOMM], [1]];
var ChangeMessageVisibilityBatchRequest = [
    3,
    n0,
    _CMVBR,
    0,
    [_QU, _E],
    [
        0,
        [
            () => ChangeMessageVisibilityBatchRequestEntryList,
            {
                [_xN]: _CMVBRE,
                [_xF]: 1,
            },
        ],
    ],
];
var ChangeMessageVisibilityBatchRequestEntry = [
    3,
    n0,
    _CMVBRE,
    0,
    [_I, _RH, _VT],
    [0, 0, 1],
];
var ChangeMessageVisibilityBatchResult = [
    3,
    n0,
    _CMVBRh,
    0,
    [_S, _F],
    [
        [
            () => ChangeMessageVisibilityBatchResultEntryList,
            {
                [_xN]: _CMVBREh,
                [_xF]: 1,
            },
        ],
        [
            () => BatchResultErrorEntryList,
            {
                [_xN]: _BREE,
                [_xF]: 1,
            },
        ],
    ],
];
var ChangeMessageVisibilityBatchResultEntry = [3, n0, _CMVBREh, 0, [_I], [0]];
var ChangeMessageVisibilityRequest = [3, n0, _CMVR, 0, [_QU, _RH, _VT], [0, 0, 1]];
var CreateQueueRequest = [
    3,
    n0,
    _CQR,
    0,
    [_QN, _At, _t],
    [
        0,
        [
            () => QueueAttributeMap,
            {
                [_xN]: _Att,
                [_xF]: 1,
            },
        ],
        [
            () => TagMap,
            {
                [_xN]: _T,
                [_xF]: 1,
            },
        ],
    ],
];
var CreateQueueResult = [3, n0, _CQRr, 0, [_QU], [0]];
var DeleteMessageBatchRequest = [
    3,
    n0,
    _DMBR,
    0,
    [_QU, _E],
    [
        0,
        [
            () => DeleteMessageBatchRequestEntryList,
            {
                [_xN]: _DMBRE,
                [_xF]: 1,
            },
        ],
    ],
];
var DeleteMessageBatchRequestEntry = [3, n0, _DMBRE, 0, [_I, _RH], [0, 0]];
var DeleteMessageBatchResult = [
    3,
    n0,
    _DMBRe,
    0,
    [_S, _F],
    [
        [
            () => DeleteMessageBatchResultEntryList,
            {
                [_xN]: _DMBREe,
                [_xF]: 1,
            },
        ],
        [
            () => BatchResultErrorEntryList,
            {
                [_xN]: _BREE,
                [_xF]: 1,
            },
        ],
    ],
];
var DeleteMessageBatchResultEntry = [3, n0, _DMBREe, 0, [_I], [0]];
var DeleteMessageRequest = [3, n0, _DMR, 0, [_QU, _RH], [0, 0]];
var DeleteQueueRequest = [3, n0, _DQR, 0, [_QU], [0]];
var EmptyBatchRequest = [
    -3,
    n0,
    _EBR,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`AWS.SimpleQueueService.EmptyBatchRequest`, 400],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(EmptyBatchRequest, EmptyBatchRequest$1);
var GetQueueAttributesRequest = [
    3,
    n0,
    _GQAR,
    0,
    [_QU, _ANt],
    [
        0,
        [
            64 | 0,
            {
                [_xN]: _ANtt,
                [_xF]: 1,
            },
        ],
    ],
];
var GetQueueAttributesResult = [
    3,
    n0,
    _GQARe,
    0,
    [_At],
    [
        [
            () => QueueAttributeMap,
            {
                [_xN]: _Att,
                [_xF]: 1,
            },
        ],
    ],
];
var GetQueueUrlRequest = [3, n0, _GQUR, 0, [_QN, _QOAWSAI], [0, 0]];
var GetQueueUrlResult = [3, n0, _GQURe, 0, [_QU], [0]];
var InvalidAddress = [
    -3,
    n0,
    _IA,
    {
        [_e]: _c,
        [_hE]: 404,
        [_aQE]: [`InvalidAddress`, 404],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(InvalidAddress, InvalidAddress$1);
var InvalidAttributeName = [
    -3,
    n0,
    _IAN,
    {
        [_e]: _c,
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(InvalidAttributeName, InvalidAttributeName$1);
var InvalidAttributeValue = [
    -3,
    n0,
    _IAV,
    {
        [_e]: _c,
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(InvalidAttributeValue, InvalidAttributeValue$1);
var InvalidBatchEntryId = [
    -3,
    n0,
    _IBEI,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`AWS.SimpleQueueService.InvalidBatchEntryId`, 400],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(InvalidBatchEntryId, InvalidBatchEntryId$1);
var InvalidIdFormat = [
    -3,
    n0,
    _IIF,
    {
        [_e]: _c,
    },
    [],
    [],
];
schema.TypeRegistry.for(n0).registerError(InvalidIdFormat, InvalidIdFormat$1);
var InvalidMessageContents = [
    -3,
    n0,
    _IMC,
    {
        [_e]: _c,
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(InvalidMessageContents, InvalidMessageContents$1);
var InvalidSecurity = [
    -3,
    n0,
    _IS,
    {
        [_e]: _c,
        [_hE]: 403,
        [_aQE]: [`InvalidSecurity`, 403],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(InvalidSecurity, InvalidSecurity$1);
var KmsAccessDenied = [
    -3,
    n0,
    _KAD,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`KMS.AccessDeniedException`, 400],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(KmsAccessDenied, KmsAccessDenied$1);
var KmsDisabled = [
    -3,
    n0,
    _KD,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`KMS.DisabledException`, 400],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(KmsDisabled, KmsDisabled$1);
var KmsInvalidKeyUsage = [
    -3,
    n0,
    _KIKU,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`KMS.InvalidKeyUsageException`, 400],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(KmsInvalidKeyUsage, KmsInvalidKeyUsage$1);
var KmsInvalidState = [
    -3,
    n0,
    _KIS,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`KMS.InvalidStateException`, 400],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(KmsInvalidState, KmsInvalidState$1);
var KmsNotFound = [
    -3,
    n0,
    _KNF,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`KMS.NotFoundException`, 400],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(KmsNotFound, KmsNotFound$1);
var KmsOptInRequired = [
    -3,
    n0,
    _KOIR,
    {
        [_e]: _c,
        [_hE]: 403,
        [_aQE]: [`KMS.OptInRequired`, 403],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(KmsOptInRequired, KmsOptInRequired$1);
var KmsThrottled = [
    -3,
    n0,
    _KT,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`KMS.ThrottlingException`, 400],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(KmsThrottled, KmsThrottled$1);
var ListDeadLetterSourceQueuesRequest = [3, n0, _LDLSQR, 0, [_QU, _NT, _MR], [0, 0, 1]];
var ListDeadLetterSourceQueuesResult = [
    3,
    n0,
    _LDLSQRi,
    0,
    [_qU, _NT],
    [
        [
            64 | 0,
            {
                [_xN]: _QU,
                [_xF]: 1,
            },
        ],
        0,
    ],
];
var ListMessageMoveTasksRequest = [3, n0, _LMMTR, 0, [_SA, _MR], [0, 1]];
var ListMessageMoveTasksResult = [
    3,
    n0,
    _LMMTRi,
    {
        [_xN]: _LMMTRi,
    },
    [_R],
    [
        [
            () => ListMessageMoveTasksResultEntryList,
            {
                [_xN]: _LMMTRE,
                [_xF]: 1,
            },
        ],
    ],
];
var ListMessageMoveTasksResultEntry = [
    3,
    n0,
    _LMMTRE,
    0,
    [_TH, _St, _SA, _DA, _MNOMPS, _ANOMM, _ANOMTM, _FR, _ST],
    [0, 0, 0, 0, 1, 1, 1, 0, 1],
];
var ListQueuesRequest = [3, n0, _LQR, 0, [_QNP, _NT, _MR], [0, 0, 1]];
var ListQueuesResult = [
    3,
    n0,
    _LQRi,
    0,
    [_QUu, _NT],
    [
        [
            64 | 0,
            {
                [_xN]: _QU,
                [_xF]: 1,
            },
        ],
        0,
    ],
];
var ListQueueTagsRequest = [3, n0, _LQTR, 0, [_QU], [0]];
var ListQueueTagsResult = [
    3,
    n0,
    _LQTRi,
    0,
    [_Ta],
    [
        [
            () => TagMap,
            {
                [_xN]: _T,
                [_xF]: 1,
            },
        ],
    ],
];
var Message = [
    3,
    n0,
    _M,
    0,
    [_MI, _RH, _MDOB, _B, _At, _MDOMA, _MA],
    [
        0,
        0,
        0,
        0,
        [
            () => MessageSystemAttributeMap,
            {
                [_xN]: _Att,
                [_xF]: 1,
            },
        ],
        0,
        [
            () => MessageBodyAttributeMap,
            {
                [_xN]: _MAe,
                [_xF]: 1,
            },
        ],
    ],
];
var MessageAttributeValue = [
    3,
    n0,
    _MAV,
    0,
    [_SV, _BV, _SLV, _BLV, _DT],
    [
        0,
        21,
        [
            () => StringList,
            {
                [_xN]: _SLVt,
                [_xF]: 1,
            },
        ],
        [
            () => BinaryList,
            {
                [_xN]: _BLVi,
                [_xF]: 1,
            },
        ],
        0,
    ],
];
var MessageNotInflight = [
    -3,
    n0,
    _MNI,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`AWS.SimpleQueueService.MessageNotInflight`, 400],
    },
    [],
    [],
];
schema.TypeRegistry.for(n0).registerError(MessageNotInflight, MessageNotInflight$1);
var MessageSystemAttributeValue = [
    3,
    n0,
    _MSAV,
    0,
    [_SV, _BV, _SLV, _BLV, _DT],
    [
        0,
        21,
        [
            () => StringList,
            {
                [_xN]: _SLVt,
                [_xF]: 1,
            },
        ],
        [
            () => BinaryList,
            {
                [_xN]: _BLVi,
                [_xF]: 1,
            },
        ],
        0,
    ],
];
var OverLimit = [
    -3,
    n0,
    _OL,
    {
        [_e]: _c,
        [_hE]: 403,
        [_aQE]: [`OverLimit`, 403],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(OverLimit, OverLimit$1);
var PurgeQueueInProgress = [
    -3,
    n0,
    _PQIP,
    {
        [_e]: _c,
        [_hE]: 403,
        [_aQE]: [`AWS.SimpleQueueService.PurgeQueueInProgress`, 403],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(PurgeQueueInProgress, PurgeQueueInProgress$1);
var PurgeQueueRequest = [3, n0, _PQR, 0, [_QU], [0]];
var QueueDeletedRecently = [
    -3,
    n0,
    _QDR,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`AWS.SimpleQueueService.QueueDeletedRecently`, 400],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(QueueDeletedRecently, QueueDeletedRecently$1);
var QueueDoesNotExist = [
    -3,
    n0,
    _QDNE,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`AWS.SimpleQueueService.NonExistentQueue`, 400],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(QueueDoesNotExist, QueueDoesNotExist$1);
var QueueNameExists = [
    -3,
    n0,
    _QNE,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`QueueAlreadyExists`, 400],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(QueueNameExists, QueueNameExists$1);
var ReceiptHandleIsInvalid = [
    -3,
    n0,
    _RHII,
    {
        [_e]: _c,
        [_hE]: 404,
        [_aQE]: [`ReceiptHandleIsInvalid`, 404],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(ReceiptHandleIsInvalid, ReceiptHandleIsInvalid$1);
var ReceiveMessageRequest = [
    3,
    n0,
    _RMR,
    0,
    [_QU, _ANt, _MSAN, _MAN, _MNOM, _VT, _WTS, _RRAI],
    [
        0,
        [
            64 | 0,
            {
                [_xN]: _ANtt,
                [_xF]: 1,
            },
        ],
        [
            64 | 0,
            {
                [_xN]: _ANtt,
                [_xF]: 1,
            },
        ],
        [
            64 | 0,
            {
                [_xN]: _MANe,
                [_xF]: 1,
            },
        ],
        1,
        1,
        1,
        0,
    ],
];
var ReceiveMessageResult = [
    3,
    n0,
    _RMRe,
    0,
    [_Me],
    [
        [
            () => MessageList,
            {
                [_xN]: _M,
                [_xF]: 1,
            },
        ],
    ],
];
var RemovePermissionRequest = [3, n0, _RPR, 0, [_QU, _L], [0, 0]];
var RequestThrottled = [
    -3,
    n0,
    _RT,
    {
        [_e]: _c,
        [_hE]: 403,
        [_aQE]: [`RequestThrottled`, 403],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(RequestThrottled, RequestThrottled$1);
var ResourceNotFoundException = [
    -3,
    n0,
    _RNFE,
    {
        [_e]: _c,
        [_hE]: 404,
        [_aQE]: [`ResourceNotFoundException`, 404],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
var SendMessageBatchRequest = [
    3,
    n0,
    _SMBR,
    0,
    [_QU, _E],
    [
        0,
        [
            () => SendMessageBatchRequestEntryList,
            {
                [_xN]: _SMBRE,
                [_xF]: 1,
            },
        ],
    ],
];
var SendMessageBatchRequestEntry = [
    3,
    n0,
    _SMBRE,
    0,
    [_I, _MB, _DS, _MA, _MSA, _MDI, _MGI],
    [
        0,
        0,
        1,
        [
            () => MessageBodyAttributeMap,
            {
                [_xN]: _MAe,
                [_xF]: 1,
            },
        ],
        [
            () => MessageBodySystemAttributeMap,
            {
                [_xN]: _MSAe,
                [_xF]: 1,
            },
        ],
        0,
        0,
    ],
];
var SendMessageBatchResult = [
    3,
    n0,
    _SMBRe,
    0,
    [_S, _F],
    [
        [
            () => SendMessageBatchResultEntryList,
            {
                [_xN]: _SMBREe,
                [_xF]: 1,
            },
        ],
        [
            () => BatchResultErrorEntryList,
            {
                [_xN]: _BREE,
                [_xF]: 1,
            },
        ],
    ],
];
var SendMessageBatchResultEntry = [
    3,
    n0,
    _SMBREe,
    0,
    [_I, _MI, _MDOMB, _MDOMA, _MDOMSA, _SN],
    [0, 0, 0, 0, 0, 0],
];
var SendMessageRequest = [
    3,
    n0,
    _SMR,
    0,
    [_QU, _MB, _DS, _MA, _MSA, _MDI, _MGI],
    [
        0,
        0,
        1,
        [
            () => MessageBodyAttributeMap,
            {
                [_xN]: _MAe,
                [_xF]: 1,
            },
        ],
        [
            () => MessageBodySystemAttributeMap,
            {
                [_xN]: _MSAe,
                [_xF]: 1,
            },
        ],
        0,
        0,
    ],
];
var SendMessageResult = [
    3,
    n0,
    _SMRe,
    0,
    [_MDOMB, _MDOMA, _MDOMSA, _MI, _SN],
    [0, 0, 0, 0, 0],
];
var SetQueueAttributesRequest = [
    3,
    n0,
    _SQAR,
    0,
    [_QU, _At],
    [
        0,
        [
            () => QueueAttributeMap,
            {
                [_xN]: _Att,
                [_xF]: 1,
            },
        ],
    ],
];
var StartMessageMoveTaskRequest = [3, n0, _SMMTR, 0, [_SA, _DA, _MNOMPS], [0, 0, 1]];
var StartMessageMoveTaskResult = [3, n0, _SMMTRt, 0, [_TH], [0]];
var TagQueueRequest = [
    3,
    n0,
    _TQR,
    0,
    [_QU, _Ta],
    [
        0,
        [
            () => TagMap,
            {
                [_xN]: _T,
                [_xF]: 1,
            },
        ],
    ],
];
var TooManyEntriesInBatchRequest = [
    -3,
    n0,
    _TMEIBR,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`AWS.SimpleQueueService.TooManyEntriesInBatchRequest`, 400],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(TooManyEntriesInBatchRequest, TooManyEntriesInBatchRequest$1);
var UnsupportedOperation = [
    -3,
    n0,
    _UO,
    {
        [_e]: _c,
        [_hE]: 400,
        [_aQE]: [`AWS.SimpleQueueService.UnsupportedOperation`, 400],
    },
    [_m],
    [0],
];
schema.TypeRegistry.for(n0).registerError(UnsupportedOperation, UnsupportedOperation$1);
var UntagQueueRequest = [
    3,
    n0,
    _UQR,
    0,
    [_QU, _TK],
    [
        0,
        [
            64 | 0,
            {
                [_xN]: _TKa,
                [_xF]: 1,
            },
        ],
    ],
];
var __Unit = "unit";
var SQSServiceException = [-3, _s, "SQSServiceException", 0, [], []];
schema.TypeRegistry.for(_s).registerError(SQSServiceException, SQSServiceException$1);
var BatchResultErrorEntryList = [1, n0, _BREEL, 0, () => BatchResultErrorEntry];
var BinaryList = [
    1,
    n0,
    _BL,
    0,
    [
        21,
        {
            [_xN]: _BLVi,
        },
    ],
];
var ChangeMessageVisibilityBatchRequestEntryList = [
    1,
    n0,
    _CMVBREL,
    0,
    () => ChangeMessageVisibilityBatchRequestEntry,
];
var ChangeMessageVisibilityBatchResultEntryList = [
    1,
    n0,
    _CMVBRELh,
    0,
    () => ChangeMessageVisibilityBatchResultEntry,
];
var DeleteMessageBatchRequestEntryList = [
    1,
    n0,
    _DMBREL,
    0,
    () => DeleteMessageBatchRequestEntry,
];
var DeleteMessageBatchResultEntryList = [
    1,
    n0,
    _DMBRELe,
    0,
    () => DeleteMessageBatchResultEntry,
];
var ListMessageMoveTasksResultEntryList = [
    1,
    n0,
    _LMMTREL,
    0,
    () => ListMessageMoveTasksResultEntry,
];
var MessageList = [1, n0, _ML, 0, [() => Message, 0]];
var SendMessageBatchRequestEntryList = [
    1,
    n0,
    _SMBREL,
    0,
    [() => SendMessageBatchRequestEntry, 0],
];
var SendMessageBatchResultEntryList = [1, n0, _SMBRELe, 0, () => SendMessageBatchResultEntry];
var StringList = [
    1,
    n0,
    _SL,
    0,
    [
        0,
        {
            [_xN]: _SLVt,
        },
    ],
];
var MessageBodyAttributeMap = [
    2,
    n0,
    _MBAM,
    0,
    [
        0,
        {
            [_xN]: _N,
        },
    ],
    [
        () => MessageAttributeValue,
        {
            [_xN]: _V,
        },
    ],
];
var MessageBodySystemAttributeMap = [
    2,
    n0,
    _MBSAM,
    0,
    [
        0,
        {
            [_xN]: _N,
        },
    ],
    [
        () => MessageSystemAttributeValue,
        {
            [_xN]: _V,
        },
    ],
];
var MessageSystemAttributeMap = [
    2,
    n0,
    _MSAM,
    0,
    [
        0,
        {
            [_xN]: _N,
        },
    ],
    [
        0,
        {
            [_xN]: _V,
        },
    ],
];
var QueueAttributeMap = [
    2,
    n0,
    _QAM,
    0,
    [
        0,
        {
            [_xN]: _N,
        },
    ],
    [
        0,
        {
            [_xN]: _V,
        },
    ],
];
var TagMap = [
    2,
    n0,
    _TM,
    0,
    [
        0,
        {
            [_xN]: _K,
        },
    ],
    [
        0,
        {
            [_xN]: _V,
        },
    ],
];
var AddPermission = [9, n0, _AP, 0, () => AddPermissionRequest, () => __Unit];
var CancelMessageMoveTask = [
    9,
    n0,
    _CMMT,
    0,
    () => CancelMessageMoveTaskRequest,
    () => CancelMessageMoveTaskResult,
];
var ChangeMessageVisibility = [
    9,
    n0,
    _CMV,
    0,
    () => ChangeMessageVisibilityRequest,
    () => __Unit,
];
var ChangeMessageVisibilityBatch = [
    9,
    n0,
    _CMVB,
    0,
    () => ChangeMessageVisibilityBatchRequest,
    () => ChangeMessageVisibilityBatchResult,
];
var CreateQueue = [9, n0, _CQ, 0, () => CreateQueueRequest, () => CreateQueueResult];
var DeleteMessage = [9, n0, _DM, 0, () => DeleteMessageRequest, () => __Unit];
var DeleteMessageBatch = [
    9,
    n0,
    _DMB,
    0,
    () => DeleteMessageBatchRequest,
    () => DeleteMessageBatchResult,
];
var DeleteQueue = [9, n0, _DQ, 0, () => DeleteQueueRequest, () => __Unit];
var GetQueueAttributes = [
    9,
    n0,
    _GQA,
    0,
    () => GetQueueAttributesRequest,
    () => GetQueueAttributesResult,
];
var GetQueueUrl = [9, n0, _GQU, 0, () => GetQueueUrlRequest, () => GetQueueUrlResult];
var ListDeadLetterSourceQueues = [
    9,
    n0,
    _LDLSQ,
    0,
    () => ListDeadLetterSourceQueuesRequest,
    () => ListDeadLetterSourceQueuesResult,
];
var ListMessageMoveTasks = [
    9,
    n0,
    _LMMT,
    0,
    () => ListMessageMoveTasksRequest,
    () => ListMessageMoveTasksResult,
];
var ListQueues = [9, n0, _LQ, 0, () => ListQueuesRequest, () => ListQueuesResult];
var ListQueueTags = [
    9,
    n0,
    _LQT,
    0,
    () => ListQueueTagsRequest,
    () => ListQueueTagsResult,
];
var PurgeQueue = [9, n0, _PQ, 0, () => PurgeQueueRequest, () => __Unit];
var ReceiveMessage = [
    9,
    n0,
    _RM,
    0,
    () => ReceiveMessageRequest,
    () => ReceiveMessageResult,
];
var RemovePermission = [9, n0, _RP, 0, () => RemovePermissionRequest, () => __Unit];
var SendMessage = [9, n0, _SM, 0, () => SendMessageRequest, () => SendMessageResult];
var SendMessageBatch = [
    9,
    n0,
    _SMB,
    0,
    () => SendMessageBatchRequest,
    () => SendMessageBatchResult,
];
var SetQueueAttributes = [9, n0, _SQA, 0, () => SetQueueAttributesRequest, () => __Unit];
var StartMessageMoveTask = [
    9,
    n0,
    _SMMT,
    0,
    () => StartMessageMoveTaskRequest,
    () => StartMessageMoveTaskResult,
];
var TagQueue = [9, n0, _TQ, 0, () => TagQueueRequest, () => __Unit];
var UntagQueue = [9, n0, _UQ, 0, () => UntagQueueRequest, () => __Unit];

class AddPermissionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "AddPermission", {})
    .n("SQSClient", "AddPermissionCommand")
    .sc(AddPermission)
    .build() {
}

class CancelMessageMoveTaskCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "CancelMessageMoveTask", {})
    .n("SQSClient", "CancelMessageMoveTaskCommand")
    .sc(CancelMessageMoveTask)
    .build() {
}

class ChangeMessageVisibilityBatchCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "ChangeMessageVisibilityBatch", {})
    .n("SQSClient", "ChangeMessageVisibilityBatchCommand")
    .sc(ChangeMessageVisibilityBatch)
    .build() {
}

class ChangeMessageVisibilityCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "ChangeMessageVisibility", {})
    .n("SQSClient", "ChangeMessageVisibilityCommand")
    .sc(ChangeMessageVisibility)
    .build() {
}

class CreateQueueCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "CreateQueue", {})
    .n("SQSClient", "CreateQueueCommand")
    .sc(CreateQueue)
    .build() {
}

class DeleteMessageBatchCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "DeleteMessageBatch", {})
    .n("SQSClient", "DeleteMessageBatchCommand")
    .sc(DeleteMessageBatch)
    .build() {
}

class DeleteMessageCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "DeleteMessage", {})
    .n("SQSClient", "DeleteMessageCommand")
    .sc(DeleteMessage)
    .build() {
}

class DeleteQueueCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "DeleteQueue", {})
    .n("SQSClient", "DeleteQueueCommand")
    .sc(DeleteQueue)
    .build() {
}

class GetQueueAttributesCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "GetQueueAttributes", {})
    .n("SQSClient", "GetQueueAttributesCommand")
    .sc(GetQueueAttributes)
    .build() {
}

class GetQueueUrlCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "GetQueueUrl", {})
    .n("SQSClient", "GetQueueUrlCommand")
    .sc(GetQueueUrl)
    .build() {
}

class ListDeadLetterSourceQueuesCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "ListDeadLetterSourceQueues", {})
    .n("SQSClient", "ListDeadLetterSourceQueuesCommand")
    .sc(ListDeadLetterSourceQueues)
    .build() {
}

class ListMessageMoveTasksCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "ListMessageMoveTasks", {})
    .n("SQSClient", "ListMessageMoveTasksCommand")
    .sc(ListMessageMoveTasks)
    .build() {
}

class ListQueuesCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "ListQueues", {})
    .n("SQSClient", "ListQueuesCommand")
    .sc(ListQueues)
    .build() {
}

class ListQueueTagsCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "ListQueueTags", {})
    .n("SQSClient", "ListQueueTagsCommand")
    .sc(ListQueueTags)
    .build() {
}

class PurgeQueueCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "PurgeQueue", {})
    .n("SQSClient", "PurgeQueueCommand")
    .sc(PurgeQueue)
    .build() {
}

class ReceiveMessageCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()), middlewareSdkSqs.getReceiveMessagePlugin(config)];
})
    .s("AmazonSQS", "ReceiveMessage", {})
    .n("SQSClient", "ReceiveMessageCommand")
    .sc(ReceiveMessage)
    .build() {
}

class RemovePermissionCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "RemovePermission", {})
    .n("SQSClient", "RemovePermissionCommand")
    .sc(RemovePermission)
    .build() {
}

class SendMessageBatchCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()), middlewareSdkSqs.getSendMessageBatchPlugin(config)];
})
    .s("AmazonSQS", "SendMessageBatch", {})
    .n("SQSClient", "SendMessageBatchCommand")
    .sc(SendMessageBatch)
    .build() {
}

class SendMessageCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()), middlewareSdkSqs.getSendMessagePlugin(config)];
})
    .s("AmazonSQS", "SendMessage", {})
    .n("SQSClient", "SendMessageCommand")
    .sc(SendMessage)
    .build() {
}

class SetQueueAttributesCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "SetQueueAttributes", {})
    .n("SQSClient", "SetQueueAttributesCommand")
    .sc(SetQueueAttributes)
    .build() {
}

class StartMessageMoveTaskCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "StartMessageMoveTask", {})
    .n("SQSClient", "StartMessageMoveTaskCommand")
    .sc(StartMessageMoveTask)
    .build() {
}

class TagQueueCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "TagQueue", {})
    .n("SQSClient", "TagQueueCommand")
    .sc(TagQueue)
    .build() {
}

class UntagQueueCommand extends smithyClient.Command
    .classBuilder()
    .ep(commonParams)
    .m(function (Command, cs, config, o) {
    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
})
    .s("AmazonSQS", "UntagQueue", {})
    .n("SQSClient", "UntagQueueCommand")
    .sc(UntagQueue)
    .build() {
}

const commands = {
    AddPermissionCommand,
    CancelMessageMoveTaskCommand,
    ChangeMessageVisibilityCommand,
    ChangeMessageVisibilityBatchCommand,
    CreateQueueCommand,
    DeleteMessageCommand,
    DeleteMessageBatchCommand,
    DeleteQueueCommand,
    GetQueueAttributesCommand,
    GetQueueUrlCommand,
    ListDeadLetterSourceQueuesCommand,
    ListMessageMoveTasksCommand,
    ListQueuesCommand,
    ListQueueTagsCommand,
    PurgeQueueCommand,
    ReceiveMessageCommand,
    RemovePermissionCommand,
    SendMessageCommand,
    SendMessageBatchCommand,
    SetQueueAttributesCommand,
    StartMessageMoveTaskCommand,
    TagQueueCommand,
    UntagQueueCommand,
};
class SQS extends SQSClient {
}
smithyClient.createAggregatedClient(commands, SQS);

const paginateListDeadLetterSourceQueues = core.createPaginator(SQSClient, ListDeadLetterSourceQueuesCommand, "NextToken", "NextToken", "MaxResults");

const paginateListQueues = core.createPaginator(SQSClient, ListQueuesCommand, "NextToken", "NextToken", "MaxResults");

Object.defineProperty(exports, "$Command", {
    enumerable: true,
    get: function () { return smithyClient.Command; }
});
Object.defineProperty(exports, "__Client", {
    enumerable: true,
    get: function () { return smithyClient.Client; }
});
exports.AddPermissionCommand = AddPermissionCommand;
exports.BatchEntryIdsNotDistinct = BatchEntryIdsNotDistinct$1;
exports.BatchRequestTooLong = BatchRequestTooLong$1;
exports.CancelMessageMoveTaskCommand = CancelMessageMoveTaskCommand;
exports.ChangeMessageVisibilityBatchCommand = ChangeMessageVisibilityBatchCommand;
exports.ChangeMessageVisibilityCommand = ChangeMessageVisibilityCommand;
exports.CreateQueueCommand = CreateQueueCommand;
exports.DeleteMessageBatchCommand = DeleteMessageBatchCommand;
exports.DeleteMessageCommand = DeleteMessageCommand;
exports.DeleteQueueCommand = DeleteQueueCommand;
exports.EmptyBatchRequest = EmptyBatchRequest$1;
exports.GetQueueAttributesCommand = GetQueueAttributesCommand;
exports.GetQueueUrlCommand = GetQueueUrlCommand;
exports.InvalidAddress = InvalidAddress$1;
exports.InvalidAttributeName = InvalidAttributeName$1;
exports.InvalidAttributeValue = InvalidAttributeValue$1;
exports.InvalidBatchEntryId = InvalidBatchEntryId$1;
exports.InvalidIdFormat = InvalidIdFormat$1;
exports.InvalidMessageContents = InvalidMessageContents$1;
exports.InvalidSecurity = InvalidSecurity$1;
exports.KmsAccessDenied = KmsAccessDenied$1;
exports.KmsDisabled = KmsDisabled$1;
exports.KmsInvalidKeyUsage = KmsInvalidKeyUsage$1;
exports.KmsInvalidState = KmsInvalidState$1;
exports.KmsNotFound = KmsNotFound$1;
exports.KmsOptInRequired = KmsOptInRequired$1;
exports.KmsThrottled = KmsThrottled$1;
exports.ListDeadLetterSourceQueuesCommand = ListDeadLetterSourceQueuesCommand;
exports.ListMessageMoveTasksCommand = ListMessageMoveTasksCommand;
exports.ListQueueTagsCommand = ListQueueTagsCommand;
exports.ListQueuesCommand = ListQueuesCommand;
exports.MessageNotInflight = MessageNotInflight$1;
exports.MessageSystemAttributeName = MessageSystemAttributeName;
exports.MessageSystemAttributeNameForSends = MessageSystemAttributeNameForSends;
exports.OverLimit = OverLimit$1;
exports.PurgeQueueCommand = PurgeQueueCommand;
exports.PurgeQueueInProgress = PurgeQueueInProgress$1;
exports.QueueAttributeName = QueueAttributeName;
exports.QueueDeletedRecently = QueueDeletedRecently$1;
exports.QueueDoesNotExist = QueueDoesNotExist$1;
exports.QueueNameExists = QueueNameExists$1;
exports.ReceiptHandleIsInvalid = ReceiptHandleIsInvalid$1;
exports.ReceiveMessageCommand = ReceiveMessageCommand;
exports.RemovePermissionCommand = RemovePermissionCommand;
exports.RequestThrottled = RequestThrottled$1;
exports.ResourceNotFoundException = ResourceNotFoundException$1;
exports.SQS = SQS;
exports.SQSClient = SQSClient;
exports.SQSServiceException = SQSServiceException$1;
exports.SendMessageBatchCommand = SendMessageBatchCommand;
exports.SendMessageCommand = SendMessageCommand;
exports.SetQueueAttributesCommand = SetQueueAttributesCommand;
exports.StartMessageMoveTaskCommand = StartMessageMoveTaskCommand;
exports.TagQueueCommand = TagQueueCommand;
exports.TooManyEntriesInBatchRequest = TooManyEntriesInBatchRequest$1;
exports.UnsupportedOperation = UnsupportedOperation$1;
exports.UntagQueueCommand = UntagQueueCommand;
exports.paginateListDeadLetterSourceQueues = paginateListDeadLetterSourceQueues;
exports.paginateListQueues = paginateListQueues;