"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  AddPermissionCommand: () => AddPermissionCommand,
  BatchEntryIdsNotDistinct: () => BatchEntryIdsNotDistinct,
  BatchRequestTooLong: () => BatchRequestTooLong,
  CancelMessageMoveTaskCommand: () => CancelMessageMoveTaskCommand,
  ChangeMessageVisibilityBatchCommand: () => ChangeMessageVisibilityBatchCommand,
  ChangeMessageVisibilityCommand: () => ChangeMessageVisibilityCommand,
  CreateQueueCommand: () => CreateQueueCommand,
  DeleteMessageBatchCommand: () => DeleteMessageBatchCommand,
  DeleteMessageCommand: () => DeleteMessageCommand,
  DeleteQueueCommand: () => DeleteQueueCommand,
  EmptyBatchRequest: () => EmptyBatchRequest,
  GetQueueAttributesCommand: () => GetQueueAttributesCommand,
  GetQueueUrlCommand: () => GetQueueUrlCommand,
  InvalidAddress: () => InvalidAddress,
  InvalidAttributeName: () => InvalidAttributeName,
  InvalidAttributeValue: () => InvalidAttributeValue,
  InvalidBatchEntryId: () => InvalidBatchEntryId,
  InvalidIdFormat: () => InvalidIdFormat,
  InvalidMessageContents: () => InvalidMessageContents,
  InvalidSecurity: () => InvalidSecurity,
  KmsAccessDenied: () => KmsAccessDenied,
  KmsDisabled: () => KmsDisabled,
  KmsInvalidKeyUsage: () => KmsInvalidKeyUsage,
  KmsInvalidState: () => KmsInvalidState,
  KmsNotFound: () => KmsNotFound,
  KmsOptInRequired: () => KmsOptInRequired,
  KmsThrottled: () => KmsThrottled,
  ListDeadLetterSourceQueuesCommand: () => ListDeadLetterSourceQueuesCommand,
  ListMessageMoveTasksCommand: () => ListMessageMoveTasksCommand,
  ListQueueTagsCommand: () => ListQueueTagsCommand,
  ListQueuesCommand: () => ListQueuesCommand,
  MessageNotInflight: () => MessageNotInflight,
  MessageSystemAttributeName: () => MessageSystemAttributeName,
  MessageSystemAttributeNameForSends: () => MessageSystemAttributeNameForSends,
  OverLimit: () => OverLimit,
  PurgeQueueCommand: () => PurgeQueueCommand,
  PurgeQueueInProgress: () => PurgeQueueInProgress,
  QueueAttributeName: () => QueueAttributeName,
  QueueDeletedRecently: () => QueueDeletedRecently,
  QueueDoesNotExist: () => QueueDoesNotExist,
  QueueNameExists: () => QueueNameExists,
  ReceiptHandleIsInvalid: () => ReceiptHandleIsInvalid,
  ReceiveMessageCommand: () => ReceiveMessageCommand,
  RemovePermissionCommand: () => RemovePermissionCommand,
  RequestThrottled: () => RequestThrottled,
  ResourceNotFoundException: () => ResourceNotFoundException,
  SQS: () => SQS,
  SQSClient: () => SQSClient,
  SQSServiceException: () => SQSServiceException,
  SendMessageBatchCommand: () => SendMessageBatchCommand,
  SendMessageCommand: () => SendMessageCommand,
  SetQueueAttributesCommand: () => SetQueueAttributesCommand,
  StartMessageMoveTaskCommand: () => StartMessageMoveTaskCommand,
  TagQueueCommand: () => TagQueueCommand,
  TooManyEntriesInBatchRequest: () => TooManyEntriesInBatchRequest,
  UnsupportedOperation: () => UnsupportedOperation,
  UntagQueueCommand: () => UntagQueueCommand,
  __Client: () => import_smithy_client.Client,
  paginateListDeadLetterSourceQueues: () => paginateListDeadLetterSourceQueues,
  paginateListQueues: () => paginateListQueues
});
module.exports = __toCommonJS(src_exports);

// src/SQSClient.ts
var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
var import_middleware_logger = require("@aws-sdk/middleware-logger");
var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
var import_middleware_sdk_sqs = require("@aws-sdk/middleware-sdk-sqs");
var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
var import_config_resolver = require("@smithy/config-resolver");
var import_core = require("@smithy/core");
var import_middleware_content_length = require("@smithy/middleware-content-length");
var import_middleware_endpoint = require("@smithy/middleware-endpoint");
var import_middleware_retry = require("@smithy/middleware-retry");

var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");

// src/endpoint/EndpointParameters.ts
var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
  return {
    ...options,
    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
    useFipsEndpoint: options.useFipsEndpoint ?? false,
    defaultSigningName: "sqs"
  };
}, "resolveClientEndpointParameters");
var commonParams = {
  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
  Endpoint: { type: "builtInParams", name: "endpoint" },
  Region: { type: "builtInParams", name: "region" },
  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};

// src/SQSClient.ts
var import_runtimeConfig = require("././runtimeConfig");

// src/runtimeExtensions.ts
var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
var import_protocol_http = require("@smithy/protocol-http");
var import_smithy_client = require("@smithy/smithy-client");

// src/auth/httpAuthExtensionConfiguration.ts
var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((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;
    }
  };
}, "getHttpAuthExtensionConfiguration");
var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
  return {
    httpAuthSchemes: config.httpAuthSchemes(),
    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
    credentials: config.credentials()
  };
}, "resolveHttpAuthRuntimeConfig");

// src/runtimeExtensions.ts
var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
  const extensionConfiguration = {
    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig)),
    ...asPartial(getHttpAuthExtensionConfiguration(runtimeConfig))
  };
  extensions.forEach((extension) => extension.configure(extensionConfiguration));
  return {
    ...runtimeConfig,
    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
    ...resolveHttpAuthRuntimeConfig(extensionConfiguration)
  };
}, "resolveRuntimeExtensions");

// src/SQSClient.ts
var _SQSClient = class _SQSClient extends import_smithy_client.Client {
  constructor(...[configuration]) {
    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
    const _config_1 = resolveClientEndpointParameters(_config_0);
    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
    const _config_7 = (0, import_middleware_sdk_sqs.resolveQueueUrlConfig)(_config_6);
    const _config_8 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_7);
    const _config_9 = resolveRuntimeExtensions(_config_8, (configuration == null ? void 0 : configuration.extensions) || []);
    super(_config_9);
    this.config = _config_9;
    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_sdk_sqs.getQueueUrlPlugin)(this.config));
    this.middlewareStack.use(
      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultSQSHttpAuthSchemeParametersProvider,
        identityProviderConfigProvider: async (config) => new import_core.DefaultIdentityProviderConfig({
          "aws.auth#sigv4": config.credentials
        })
      })
    );
    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
  }
  /**
   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
   */
  destroy() {
    super.destroy();
  }
};
__name(_SQSClient, "SQSClient");
var SQSClient = _SQSClient;

// src/SQS.ts


// src/commands/AddPermissionCommand.ts

var import_middleware_serde = require("@smithy/middleware-serde");


// src/protocols/Aws_json1_0.ts
var import_core2 = require("@aws-sdk/core");



// src/models/SQSServiceException.ts

var _SQSServiceException = class _SQSServiceException extends import_smithy_client.ServiceException {
  /**
   * @internal
   */
  constructor(options) {
    super(options);
    Object.setPrototypeOf(this, _SQSServiceException.prototype);
  }
};
__name(_SQSServiceException, "SQSServiceException");
var SQSServiceException = _SQSServiceException;

// src/models/models_0.ts
var _InvalidAddress = class _InvalidAddress extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidAddress",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidAddress";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidAddress.prototype);
  }
};
__name(_InvalidAddress, "InvalidAddress");
var InvalidAddress = _InvalidAddress;
var _InvalidSecurity = class _InvalidSecurity extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidSecurity",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidSecurity";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidSecurity.prototype);
  }
};
__name(_InvalidSecurity, "InvalidSecurity");
var InvalidSecurity = _InvalidSecurity;
var _OverLimit = class _OverLimit extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "OverLimit",
      $fault: "client",
      ...opts
    });
    this.name = "OverLimit";
    this.$fault = "client";
    Object.setPrototypeOf(this, _OverLimit.prototype);
  }
};
__name(_OverLimit, "OverLimit");
var OverLimit = _OverLimit;
var _QueueDoesNotExist = class _QueueDoesNotExist extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "QueueDoesNotExist",
      $fault: "client",
      ...opts
    });
    this.name = "QueueDoesNotExist";
    this.$fault = "client";
    Object.setPrototypeOf(this, _QueueDoesNotExist.prototype);
  }
};
__name(_QueueDoesNotExist, "QueueDoesNotExist");
var QueueDoesNotExist = _QueueDoesNotExist;
var _RequestThrottled = class _RequestThrottled extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "RequestThrottled",
      $fault: "client",
      ...opts
    });
    this.name = "RequestThrottled";
    this.$fault = "client";
    Object.setPrototypeOf(this, _RequestThrottled.prototype);
  }
};
__name(_RequestThrottled, "RequestThrottled");
var RequestThrottled = _RequestThrottled;
var _UnsupportedOperation = class _UnsupportedOperation extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UnsupportedOperation",
      $fault: "client",
      ...opts
    });
    this.name = "UnsupportedOperation";
    this.$fault = "client";
    Object.setPrototypeOf(this, _UnsupportedOperation.prototype);
  }
};
__name(_UnsupportedOperation, "UnsupportedOperation");
var UnsupportedOperation = _UnsupportedOperation;
var _ResourceNotFoundException = class _ResourceNotFoundException extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "ResourceNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
  }
};
__name(_ResourceNotFoundException, "ResourceNotFoundException");
var ResourceNotFoundException = _ResourceNotFoundException;
var _MessageNotInflight = class _MessageNotInflight extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "MessageNotInflight",
      $fault: "client",
      ...opts
    });
    this.name = "MessageNotInflight";
    this.$fault = "client";
    Object.setPrototypeOf(this, _MessageNotInflight.prototype);
  }
};
__name(_MessageNotInflight, "MessageNotInflight");
var MessageNotInflight = _MessageNotInflight;
var _ReceiptHandleIsInvalid = class _ReceiptHandleIsInvalid extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ReceiptHandleIsInvalid",
      $fault: "client",
      ...opts
    });
    this.name = "ReceiptHandleIsInvalid";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ReceiptHandleIsInvalid.prototype);
  }
};
__name(_ReceiptHandleIsInvalid, "ReceiptHandleIsInvalid");
var ReceiptHandleIsInvalid = _ReceiptHandleIsInvalid;
var _BatchEntryIdsNotDistinct = class _BatchEntryIdsNotDistinct extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "BatchEntryIdsNotDistinct",
      $fault: "client",
      ...opts
    });
    this.name = "BatchEntryIdsNotDistinct";
    this.$fault = "client";
    Object.setPrototypeOf(this, _BatchEntryIdsNotDistinct.prototype);
  }
};
__name(_BatchEntryIdsNotDistinct, "BatchEntryIdsNotDistinct");
var BatchEntryIdsNotDistinct = _BatchEntryIdsNotDistinct;
var _EmptyBatchRequest = class _EmptyBatchRequest extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "EmptyBatchRequest",
      $fault: "client",
      ...opts
    });
    this.name = "EmptyBatchRequest";
    this.$fault = "client";
    Object.setPrototypeOf(this, _EmptyBatchRequest.prototype);
  }
};
__name(_EmptyBatchRequest, "EmptyBatchRequest");
var EmptyBatchRequest = _EmptyBatchRequest;
var _InvalidBatchEntryId = class _InvalidBatchEntryId extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidBatchEntryId",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidBatchEntryId";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidBatchEntryId.prototype);
  }
};
__name(_InvalidBatchEntryId, "InvalidBatchEntryId");
var InvalidBatchEntryId = _InvalidBatchEntryId;
var _TooManyEntriesInBatchRequest = class _TooManyEntriesInBatchRequest extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TooManyEntriesInBatchRequest",
      $fault: "client",
      ...opts
    });
    this.name = "TooManyEntriesInBatchRequest";
    this.$fault = "client";
    Object.setPrototypeOf(this, _TooManyEntriesInBatchRequest.prototype);
  }
};
__name(_TooManyEntriesInBatchRequest, "TooManyEntriesInBatchRequest");
var TooManyEntriesInBatchRequest = _TooManyEntriesInBatchRequest;
var 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"
};
var _InvalidAttributeName = class _InvalidAttributeName extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidAttributeName",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidAttributeName";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidAttributeName.prototype);
  }
};
__name(_InvalidAttributeName, "InvalidAttributeName");
var InvalidAttributeName = _InvalidAttributeName;
var _InvalidAttributeValue = class _InvalidAttributeValue extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidAttributeValue",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidAttributeValue";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidAttributeValue.prototype);
  }
};
__name(_InvalidAttributeValue, "InvalidAttributeValue");
var InvalidAttributeValue = _InvalidAttributeValue;
var _QueueDeletedRecently = class _QueueDeletedRecently extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "QueueDeletedRecently",
      $fault: "client",
      ...opts
    });
    this.name = "QueueDeletedRecently";
    this.$fault = "client";
    Object.setPrototypeOf(this, _QueueDeletedRecently.prototype);
  }
};
__name(_QueueDeletedRecently, "QueueDeletedRecently");
var QueueDeletedRecently = _QueueDeletedRecently;
var _QueueNameExists = class _QueueNameExists extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "QueueNameExists",
      $fault: "client",
      ...opts
    });
    this.name = "QueueNameExists";
    this.$fault = "client";
    Object.setPrototypeOf(this, _QueueNameExists.prototype);
  }
};
__name(_QueueNameExists, "QueueNameExists");
var QueueNameExists = _QueueNameExists;
var _InvalidIdFormat = class _InvalidIdFormat extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidIdFormat",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidIdFormat";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidIdFormat.prototype);
  }
};
__name(_InvalidIdFormat, "InvalidIdFormat");
var InvalidIdFormat = _InvalidIdFormat;
var _PurgeQueueInProgress = class _PurgeQueueInProgress extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "PurgeQueueInProgress",
      $fault: "client",
      ...opts
    });
    this.name = "PurgeQueueInProgress";
    this.$fault = "client";
    Object.setPrototypeOf(this, _PurgeQueueInProgress.prototype);
  }
};
__name(_PurgeQueueInProgress, "PurgeQueueInProgress");
var PurgeQueueInProgress = _PurgeQueueInProgress;
var _KmsAccessDenied = class _KmsAccessDenied extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KmsAccessDenied",
      $fault: "client",
      ...opts
    });
    this.name = "KmsAccessDenied";
    this.$fault = "client";
    Object.setPrototypeOf(this, _KmsAccessDenied.prototype);
  }
};
__name(_KmsAccessDenied, "KmsAccessDenied");
var KmsAccessDenied = _KmsAccessDenied;
var _KmsDisabled = class _KmsDisabled extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KmsDisabled",
      $fault: "client",
      ...opts
    });
    this.name = "KmsDisabled";
    this.$fault = "client";
    Object.setPrototypeOf(this, _KmsDisabled.prototype);
  }
};
__name(_KmsDisabled, "KmsDisabled");
var KmsDisabled = _KmsDisabled;
var _KmsInvalidKeyUsage = class _KmsInvalidKeyUsage extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KmsInvalidKeyUsage",
      $fault: "client",
      ...opts
    });
    this.name = "KmsInvalidKeyUsage";
    this.$fault = "client";
    Object.setPrototypeOf(this, _KmsInvalidKeyUsage.prototype);
  }
};
__name(_KmsInvalidKeyUsage, "KmsInvalidKeyUsage");
var KmsInvalidKeyUsage = _KmsInvalidKeyUsage;
var _KmsInvalidState = class _KmsInvalidState extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KmsInvalidState",
      $fault: "client",
      ...opts
    });
    this.name = "KmsInvalidState";
    this.$fault = "client";
    Object.setPrototypeOf(this, _KmsInvalidState.prototype);
  }
};
__name(_KmsInvalidState, "KmsInvalidState");
var KmsInvalidState = _KmsInvalidState;
var _KmsNotFound = class _KmsNotFound extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KmsNotFound",
      $fault: "client",
      ...opts
    });
    this.name = "KmsNotFound";
    this.$fault = "client";
    Object.setPrototypeOf(this, _KmsNotFound.prototype);
  }
};
__name(_KmsNotFound, "KmsNotFound");
var KmsNotFound = _KmsNotFound;
var _KmsOptInRequired = class _KmsOptInRequired extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KmsOptInRequired",
      $fault: "client",
      ...opts
    });
    this.name = "KmsOptInRequired";
    this.$fault = "client";
    Object.setPrototypeOf(this, _KmsOptInRequired.prototype);
  }
};
__name(_KmsOptInRequired, "KmsOptInRequired");
var KmsOptInRequired = _KmsOptInRequired;
var _KmsThrottled = class _KmsThrottled extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KmsThrottled",
      $fault: "client",
      ...opts
    });
    this.name = "KmsThrottled";
    this.$fault = "client";
    Object.setPrototypeOf(this, _KmsThrottled.prototype);
  }
};
__name(_KmsThrottled, "KmsThrottled");
var KmsThrottled = _KmsThrottled;
var MessageSystemAttributeName = {
  AWSTraceHeader: "AWSTraceHeader",
  All: "All",
  ApproximateFirstReceiveTimestamp: "ApproximateFirstReceiveTimestamp",
  ApproximateReceiveCount: "ApproximateReceiveCount",
  DeadLetterQueueSourceArn: "DeadLetterQueueSourceArn",
  MessageDeduplicationId: "MessageDeduplicationId",
  MessageGroupId: "MessageGroupId",
  SenderId: "SenderId",
  SentTimestamp: "SentTimestamp",
  SequenceNumber: "SequenceNumber"
};
var _InvalidMessageContents = class _InvalidMessageContents extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidMessageContents",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidMessageContents";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidMessageContents.prototype);
  }
};
__name(_InvalidMessageContents, "InvalidMessageContents");
var InvalidMessageContents = _InvalidMessageContents;
var MessageSystemAttributeNameForSends = {
  AWSTraceHeader: "AWSTraceHeader"
};
var _BatchRequestTooLong = class _BatchRequestTooLong extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "BatchRequestTooLong",
      $fault: "client",
      ...opts
    });
    this.name = "BatchRequestTooLong";
    this.$fault = "client";
    Object.setPrototypeOf(this, _BatchRequestTooLong.prototype);
  }
};
__name(_BatchRequestTooLong, "BatchRequestTooLong");
var BatchRequestTooLong = _BatchRequestTooLong;

// src/protocols/Aws_json1_0.ts
var se_AddPermissionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("AddPermission");
  let body;
  body = JSON.stringify(se_AddPermissionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_AddPermissionCommand");
var se_CancelMessageMoveTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CancelMessageMoveTask");
  let body;
  body = JSON.stringify(se_CancelMessageMoveTaskRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CancelMessageMoveTaskCommand");
var se_ChangeMessageVisibilityCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ChangeMessageVisibility");
  let body;
  body = JSON.stringify(se_ChangeMessageVisibilityRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ChangeMessageVisibilityCommand");
var se_ChangeMessageVisibilityBatchCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ChangeMessageVisibilityBatch");
  let body;
  body = JSON.stringify(se_ChangeMessageVisibilityBatchRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ChangeMessageVisibilityBatchCommand");
var se_CreateQueueCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreateQueue");
  let body;
  body = JSON.stringify(se_CreateQueueRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreateQueueCommand");
var se_DeleteMessageCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteMessage");
  let body;
  body = JSON.stringify(se_DeleteMessageRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteMessageCommand");
var se_DeleteMessageBatchCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteMessageBatch");
  let body;
  body = JSON.stringify(se_DeleteMessageBatchRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteMessageBatchCommand");
var se_DeleteQueueCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteQueue");
  let body;
  body = JSON.stringify(se_DeleteQueueRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteQueueCommand");
var se_GetQueueAttributesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetQueueAttributes");
  let body;
  body = JSON.stringify(se_GetQueueAttributesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetQueueAttributesCommand");
var se_GetQueueUrlCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetQueueUrl");
  let body;
  body = JSON.stringify(se_GetQueueUrlRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetQueueUrlCommand");
var se_ListDeadLetterSourceQueuesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListDeadLetterSourceQueues");
  let body;
  body = JSON.stringify(se_ListDeadLetterSourceQueuesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListDeadLetterSourceQueuesCommand");
var se_ListMessageMoveTasksCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListMessageMoveTasks");
  let body;
  body = JSON.stringify(se_ListMessageMoveTasksRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListMessageMoveTasksCommand");
var se_ListQueuesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListQueues");
  let body;
  body = JSON.stringify(se_ListQueuesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListQueuesCommand");
var se_ListQueueTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListQueueTags");
  let body;
  body = JSON.stringify(se_ListQueueTagsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListQueueTagsCommand");
var se_PurgeQueueCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PurgeQueue");
  let body;
  body = JSON.stringify(se_PurgeQueueRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PurgeQueueCommand");
var se_ReceiveMessageCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ReceiveMessage");
  let body;
  body = JSON.stringify(se_ReceiveMessageRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ReceiveMessageCommand");
var se_RemovePermissionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("RemovePermission");
  let body;
  body = JSON.stringify(se_RemovePermissionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_RemovePermissionCommand");
var se_SendMessageCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("SendMessage");
  let body;
  body = JSON.stringify(se_SendMessageRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_SendMessageCommand");
var se_SendMessageBatchCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("SendMessageBatch");
  let body;
  body = JSON.stringify(se_SendMessageBatchRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_SendMessageBatchCommand");
var se_SetQueueAttributesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("SetQueueAttributes");
  let body;
  body = JSON.stringify(se_SetQueueAttributesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_SetQueueAttributesCommand");
var se_StartMessageMoveTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("StartMessageMoveTask");
  let body;
  body = JSON.stringify(se_StartMessageMoveTaskRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_StartMessageMoveTaskCommand");
var se_TagQueueCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("TagQueue");
  let body;
  body = JSON.stringify(se_TagQueueRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_TagQueueCommand");
var se_UntagQueueCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("UntagQueue");
  let body;
  body = JSON.stringify(se_UntagQueueRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_UntagQueueCommand");
var de_AddPermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_AddPermissionCommand");
var de_CancelMessageMoveTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_CancelMessageMoveTaskCommand");
var de_ChangeMessageVisibilityCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_ChangeMessageVisibilityCommand");
var de_ChangeMessageVisibilityBatchCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ChangeMessageVisibilityBatchCommand");
var de_CreateQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_CreateQueueCommand");
var de_DeleteMessageCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_DeleteMessageCommand");
var de_DeleteMessageBatchCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DeleteMessageBatchCommand");
var de_DeleteQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_DeleteQueueCommand");
var de_GetQueueAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_GetQueueAttributesCommand");
var de_GetQueueUrlCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_GetQueueUrlCommand");
var de_ListDeadLetterSourceQueuesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListDeadLetterSourceQueuesCommand");
var de_ListMessageMoveTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListMessageMoveTasksCommand");
var de_ListQueuesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListQueuesCommand");
var de_ListQueueTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListQueueTagsCommand");
var de_PurgeQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_PurgeQueueCommand");
var de_ReceiveMessageCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_ReceiveMessageResult(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ReceiveMessageCommand");
var de_RemovePermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_RemovePermissionCommand");
var de_SendMessageCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_SendMessageCommand");
var de_SendMessageBatchCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_SendMessageBatchCommand");
var de_SetQueueAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_SetQueueAttributesCommand");
var de_StartMessageMoveTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_StartMessageMoveTaskCommand");
var de_TagQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_TagQueueCommand");
var de_UntagQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_UntagQueueCommand");
var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
  const parsedOutput = {
    ...output,
    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
  };
  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
  switch (errorCode) {
    case "InvalidAddress":
    case "com.amazonaws.sqs#InvalidAddress":
      throw await de_InvalidAddressRes(parsedOutput, context);
    case "InvalidSecurity":
    case "com.amazonaws.sqs#InvalidSecurity":
      throw await de_InvalidSecurityRes(parsedOutput, context);
    case "OverLimit":
    case "com.amazonaws.sqs#OverLimit":
      throw await de_OverLimitRes(parsedOutput, context);
    case "QueueDoesNotExist":
    case "com.amazonaws.sqs#QueueDoesNotExist":
      throw await de_QueueDoesNotExistRes(parsedOutput, context);
    case "RequestThrottled":
    case "com.amazonaws.sqs#RequestThrottled":
      throw await de_RequestThrottledRes(parsedOutput, context);
    case "UnsupportedOperation":
    case "com.amazonaws.sqs#UnsupportedOperation":
      throw await de_UnsupportedOperationRes(parsedOutput, context);
    case "ResourceNotFoundException":
    case "com.amazonaws.sqs#ResourceNotFoundException":
      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
    case "MessageNotInflight":
    case "com.amazonaws.sqs#MessageNotInflight":
      throw await de_MessageNotInflightRes(parsedOutput, context);
    case "ReceiptHandleIsInvalid":
    case "com.amazonaws.sqs#ReceiptHandleIsInvalid":
      throw await de_ReceiptHandleIsInvalidRes(parsedOutput, context);
    case "BatchEntryIdsNotDistinct":
    case "com.amazonaws.sqs#BatchEntryIdsNotDistinct":
      throw await de_BatchEntryIdsNotDistinctRes(parsedOutput, context);
    case "EmptyBatchRequest":
    case "com.amazonaws.sqs#EmptyBatchRequest":
      throw await de_EmptyBatchRequestRes(parsedOutput, context);
    case "InvalidBatchEntryId":
    case "com.amazonaws.sqs#InvalidBatchEntryId":
      throw await de_InvalidBatchEntryIdRes(parsedOutput, context);
    case "TooManyEntriesInBatchRequest":
    case "com.amazonaws.sqs#TooManyEntriesInBatchRequest":
      throw await de_TooManyEntriesInBatchRequestRes(parsedOutput, context);
    case "InvalidAttributeName":
    case "com.amazonaws.sqs#InvalidAttributeName":
      throw await de_InvalidAttributeNameRes(parsedOutput, context);
    case "InvalidAttributeValue":
    case "com.amazonaws.sqs#InvalidAttributeValue":
      throw await de_InvalidAttributeValueRes(parsedOutput, context);
    case "QueueDeletedRecently":
    case "com.amazonaws.sqs#QueueDeletedRecently":
      throw await de_QueueDeletedRecentlyRes(parsedOutput, context);
    case "QueueNameExists":
    case "com.amazonaws.sqs#QueueNameExists":
      throw await de_QueueNameExistsRes(parsedOutput, context);
    case "InvalidIdFormat":
    case "com.amazonaws.sqs#InvalidIdFormat":
      throw await de_InvalidIdFormatRes(parsedOutput, context);
    case "PurgeQueueInProgress":
    case "com.amazonaws.sqs#PurgeQueueInProgress":
      throw await de_PurgeQueueInProgressRes(parsedOutput, context);
    case "KmsAccessDenied":
    case "com.amazonaws.sqs#KmsAccessDenied":
      throw await de_KmsAccessDeniedRes(parsedOutput, context);
    case "KmsDisabled":
    case "com.amazonaws.sqs#KmsDisabled":
      throw await de_KmsDisabledRes(parsedOutput, context);
    case "KmsInvalidKeyUsage":
    case "com.amazonaws.sqs#KmsInvalidKeyUsage":
      throw await de_KmsInvalidKeyUsageRes(parsedOutput, context);
    case "KmsInvalidState":
    case "com.amazonaws.sqs#KmsInvalidState":
      throw await de_KmsInvalidStateRes(parsedOutput, context);
    case "KmsNotFound":
    case "com.amazonaws.sqs#KmsNotFound":
      throw await de_KmsNotFoundRes(parsedOutput, context);
    case "KmsOptInRequired":
    case "com.amazonaws.sqs#KmsOptInRequired":
      throw await de_KmsOptInRequiredRes(parsedOutput, context);
    case "KmsThrottled":
    case "com.amazonaws.sqs#KmsThrottled":
      throw await de_KmsThrottledRes(parsedOutput, context);
    case "InvalidMessageContents":
    case "com.amazonaws.sqs#InvalidMessageContents":
      throw await de_InvalidMessageContentsRes(parsedOutput, context);
    case "BatchRequestTooLong":
    case "com.amazonaws.sqs#BatchRequestTooLong":
      throw await de_BatchRequestTooLongRes(parsedOutput, context);
    default:
      const parsedBody = parsedOutput.body;
      return throwDefaultError({
        output,
        parsedBody,
        errorCode
      });
  }
}, "de_CommandError");
var de_BatchEntryIdsNotDistinctRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new BatchEntryIdsNotDistinct({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_BatchEntryIdsNotDistinctRes");
var de_BatchRequestTooLongRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new BatchRequestTooLong({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_BatchRequestTooLongRes");
var de_EmptyBatchRequestRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new EmptyBatchRequest({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_EmptyBatchRequestRes");
var de_InvalidAddressRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new InvalidAddress({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidAddressRes");
var de_InvalidAttributeNameRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new InvalidAttributeName({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidAttributeNameRes");
var de_InvalidAttributeValueRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new InvalidAttributeValue({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidAttributeValueRes");
var de_InvalidBatchEntryIdRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new InvalidBatchEntryId({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidBatchEntryIdRes");
var de_InvalidIdFormatRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new InvalidIdFormat({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidIdFormatRes");
var de_InvalidMessageContentsRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new InvalidMessageContents({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidMessageContentsRes");
var de_InvalidSecurityRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new InvalidSecurity({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidSecurityRes");
var de_KmsAccessDeniedRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new KmsAccessDenied({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_KmsAccessDeniedRes");
var de_KmsDisabledRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new KmsDisabled({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_KmsDisabledRes");
var de_KmsInvalidKeyUsageRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new KmsInvalidKeyUsage({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_KmsInvalidKeyUsageRes");
var de_KmsInvalidStateRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new KmsInvalidState({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_KmsInvalidStateRes");
var de_KmsNotFoundRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new KmsNotFound({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_KmsNotFoundRes");
var de_KmsOptInRequiredRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new KmsOptInRequired({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_KmsOptInRequiredRes");
var de_KmsThrottledRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new KmsThrottled({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_KmsThrottledRes");
var de_MessageNotInflightRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new MessageNotInflight({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_MessageNotInflightRes");
var de_OverLimitRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new OverLimit({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_OverLimitRes");
var de_PurgeQueueInProgressRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new PurgeQueueInProgress({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_PurgeQueueInProgressRes");
var de_QueueDeletedRecentlyRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new QueueDeletedRecently({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_QueueDeletedRecentlyRes");
var de_QueueDoesNotExistRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new QueueDoesNotExist({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_QueueDoesNotExistRes");
var de_QueueNameExistsRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new QueueNameExists({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_QueueNameExistsRes");
var de_ReceiptHandleIsInvalidRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new ReceiptHandleIsInvalid({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_ReceiptHandleIsInvalidRes");
var de_RequestThrottledRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new RequestThrottled({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_RequestThrottledRes");
var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new ResourceNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_ResourceNotFoundExceptionRes");
var de_TooManyEntriesInBatchRequestRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new TooManyEntriesInBatchRequest({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_TooManyEntriesInBatchRequestRes");
var de_UnsupportedOperationRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new UnsupportedOperation({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_UnsupportedOperationRes");
var se_ActionNameList = /* @__PURE__ */ __name((input, context) => {
  return input.filter((e) => e != null).map((entry) => {
    return (0, import_core2._toStr)(entry);
  });
}, "se_ActionNameList");
var se_AddPermissionRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    AWSAccountIds: (_) => se_AWSAccountIdList(_, context),
    Actions: (_) => se_ActionNameList(_, context),
    Label: import_core2._toStr,
    QueueUrl: import_core2._toStr
  });
}, "se_AddPermissionRequest");
var se_AttributeNameList = /* @__PURE__ */ __name((input, context) => {
  return input.filter((e) => e != null).map((entry) => {
    return (0, import_core2._toStr)(entry);
  });
}, "se_AttributeNameList");
var se_AWSAccountIdList = /* @__PURE__ */ __name((input, context) => {
  return input.filter((e) => e != null).map((entry) => {
    return (0, import_core2._toStr)(entry);
  });
}, "se_AWSAccountIdList");
var se_BinaryList = /* @__PURE__ */ __name((input, context) => {
  return input.filter((e) => e != null).map((entry) => {
    return context.base64Encoder(entry);
  });
}, "se_BinaryList");
var se_CancelMessageMoveTaskRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    TaskHandle: import_core2._toStr
  });
}, "se_CancelMessageMoveTaskRequest");
var se_ChangeMessageVisibilityBatchRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    Entries: (_) => se_ChangeMessageVisibilityBatchRequestEntryList(_, context),
    QueueUrl: import_core2._toStr
  });
}, "se_ChangeMessageVisibilityBatchRequest");
var se_ChangeMessageVisibilityBatchRequestEntry = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    Id: import_core2._toStr,
    ReceiptHandle: import_core2._toStr,
    VisibilityTimeout: import_core2._toNum
  });
}, "se_ChangeMessageVisibilityBatchRequestEntry");
var se_ChangeMessageVisibilityBatchRequestEntryList = /* @__PURE__ */ __name((input, context) => {
  return input.filter((e) => e != null).map((entry) => {
    return se_ChangeMessageVisibilityBatchRequestEntry(entry, context);
  });
}, "se_ChangeMessageVisibilityBatchRequestEntryList");
var se_ChangeMessageVisibilityRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    QueueUrl: import_core2._toStr,
    ReceiptHandle: import_core2._toStr,
    VisibilityTimeout: import_core2._toNum
  });
}, "se_ChangeMessageVisibilityRequest");
var se_CreateQueueRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    Attributes: (_) => se_QueueAttributeMap(_, context),
    QueueName: import_core2._toStr,
    tags: (_) => se_TagMap(_, context)
  });
}, "se_CreateQueueRequest");
var se_DeleteMessageBatchRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    Entries: (_) => se_DeleteMessageBatchRequestEntryList(_, context),
    QueueUrl: import_core2._toStr
  });
}, "se_DeleteMessageBatchRequest");
var se_DeleteMessageBatchRequestEntry = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    Id: import_core2._toStr,
    ReceiptHandle: import_core2._toStr
  });
}, "se_DeleteMessageBatchRequestEntry");
var se_DeleteMessageBatchRequestEntryList = /* @__PURE__ */ __name((input, context) => {
  return input.filter((e) => e != null).map((entry) => {
    return se_DeleteMessageBatchRequestEntry(entry, context);
  });
}, "se_DeleteMessageBatchRequestEntryList");
var se_DeleteMessageRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    QueueUrl: import_core2._toStr,
    ReceiptHandle: import_core2._toStr
  });
}, "se_DeleteMessageRequest");
var se_DeleteQueueRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    QueueUrl: import_core2._toStr
  });
}, "se_DeleteQueueRequest");
var se_GetQueueAttributesRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    AttributeNames: (_) => se_AttributeNameList(_, context),
    QueueUrl: import_core2._toStr
  });
}, "se_GetQueueAttributesRequest");
var se_GetQueueUrlRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    QueueName: import_core2._toStr,
    QueueOwnerAWSAccountId: import_core2._toStr
  });
}, "se_GetQueueUrlRequest");
var se_ListDeadLetterSourceQueuesRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    MaxResults: import_core2._toNum,
    NextToken: import_core2._toStr,
    QueueUrl: import_core2._toStr
  });
}, "se_ListDeadLetterSourceQueuesRequest");
var se_ListMessageMoveTasksRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    MaxResults: import_core2._toNum,
    SourceArn: import_core2._toStr
  });
}, "se_ListMessageMoveTasksRequest");
var se_ListQueuesRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    MaxResults: import_core2._toNum,
    NextToken: import_core2._toStr,
    QueueNamePrefix: import_core2._toStr
  });
}, "se_ListQueuesRequest");
var se_ListQueueTagsRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    QueueUrl: import_core2._toStr
  });
}, "se_ListQueueTagsRequest");
var se_MessageAttributeNameList = /* @__PURE__ */ __name((input, context) => {
  return input.filter((e) => e != null).map((entry) => {
    return (0, import_core2._toStr)(entry);
  });
}, "se_MessageAttributeNameList");
var se_MessageAttributeValue = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    BinaryListValues: (_) => se_BinaryList(_, context),
    BinaryValue: context.base64Encoder,
    DataType: import_core2._toStr,
    StringListValues: (_) => se_StringList(_, context),
    StringValue: import_core2._toStr
  });
}, "se_MessageAttributeValue");
var se_MessageBodyAttributeMap = /* @__PURE__ */ __name((input, context) => {
  return Object.entries(input).reduce((acc, [key, value]) => {
    if (value === null) {
      return acc;
    }
    acc[key] = se_MessageAttributeValue(value, context);
    return acc;
  }, {});
}, "se_MessageBodyAttributeMap");
var se_MessageBodySystemAttributeMap = /* @__PURE__ */ __name((input, context) => {
  return Object.entries(input).reduce(
    (acc, [key, value]) => {
      if (value === null) {
        return acc;
      }
      acc[key] = se_MessageSystemAttributeValue(value, context);
      return acc;
    },
    {}
  );
}, "se_MessageBodySystemAttributeMap");
var se_MessageSystemAttributeList = /* @__PURE__ */ __name((input, context) => {
  return input.filter((e) => e != null).map((entry) => {
    return (0, import_core2._toStr)(entry);
  });
}, "se_MessageSystemAttributeList");
var se_MessageSystemAttributeValue = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    BinaryListValues: (_) => se_BinaryList(_, context),
    BinaryValue: context.base64Encoder,
    DataType: import_core2._toStr,
    StringListValues: (_) => se_StringList(_, context),
    StringValue: import_core2._toStr
  });
}, "se_MessageSystemAttributeValue");
var se_PurgeQueueRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    QueueUrl: import_core2._toStr
  });
}, "se_PurgeQueueRequest");
var se_QueueAttributeMap = /* @__PURE__ */ __name((input, context) => {
  return Object.entries(input).reduce((acc, [key, value]) => {
    if (value === null) {
      return acc;
    }
    acc[key] = (0, import_core2._toStr)(value);
    return acc;
  }, {});
}, "se_QueueAttributeMap");
var se_ReceiveMessageRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    AttributeNames: (_) => se_AttributeNameList(_, context),
    MaxNumberOfMessages: import_core2._toNum,
    MessageAttributeNames: (_) => se_MessageAttributeNameList(_, context),
    MessageSystemAttributeNames: (_) => se_MessageSystemAttributeList(_, context),
    QueueUrl: import_core2._toStr,
    ReceiveRequestAttemptId: import_core2._toStr,
    VisibilityTimeout: import_core2._toNum,
    WaitTimeSeconds: import_core2._toNum
  });
}, "se_ReceiveMessageRequest");
var se_RemovePermissionRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    Label: import_core2._toStr,
    QueueUrl: import_core2._toStr
  });
}, "se_RemovePermissionRequest");
var se_SendMessageBatchRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    Entries: (_) => se_SendMessageBatchRequestEntryList(_, context),
    QueueUrl: import_core2._toStr
  });
}, "se_SendMessageBatchRequest");
var se_SendMessageBatchRequestEntry = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    DelaySeconds: import_core2._toNum,
    Id: import_core2._toStr,
    MessageAttributes: (_) => se_MessageBodyAttributeMap(_, context),
    MessageBody: import_core2._toStr,
    MessageDeduplicationId: import_core2._toStr,
    MessageGroupId: import_core2._toStr,
    MessageSystemAttributes: (_) => se_MessageBodySystemAttributeMap(_, context)
  });
}, "se_SendMessageBatchRequestEntry");
var se_SendMessageBatchRequestEntryList = /* @__PURE__ */ __name((input, context) => {
  return input.filter((e) => e != null).map((entry) => {
    return se_SendMessageBatchRequestEntry(entry, context);
  });
}, "se_SendMessageBatchRequestEntryList");
var se_SendMessageRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    DelaySeconds: import_core2._toNum,
    MessageAttributes: (_) => se_MessageBodyAttributeMap(_, context),
    MessageBody: import_core2._toStr,
    MessageDeduplicationId: import_core2._toStr,
    MessageGroupId: import_core2._toStr,
    MessageSystemAttributes: (_) => se_MessageBodySystemAttributeMap(_, context),
    QueueUrl: import_core2._toStr
  });
}, "se_SendMessageRequest");
var se_SetQueueAttributesRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    Attributes: (_) => se_QueueAttributeMap(_, context),
    QueueUrl: import_core2._toStr
  });
}, "se_SetQueueAttributesRequest");
var se_StartMessageMoveTaskRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    DestinationArn: import_core2._toStr,
    MaxNumberOfMessagesPerSecond: import_core2._toNum,
    SourceArn: import_core2._toStr
  });
}, "se_StartMessageMoveTaskRequest");
var se_StringList = /* @__PURE__ */ __name((input, context) => {
  return input.filter((e) => e != null).map((entry) => {
    return (0, import_core2._toStr)(entry);
  });
}, "se_StringList");
var se_TagKeyList = /* @__PURE__ */ __name((input, context) => {
  return input.filter((e) => e != null).map((entry) => {
    return (0, import_core2._toStr)(entry);
  });
}, "se_TagKeyList");
var se_TagMap = /* @__PURE__ */ __name((input, context) => {
  return Object.entries(input).reduce((acc, [key, value]) => {
    if (value === null) {
      return acc;
    }
    acc[key] = (0, import_core2._toStr)(value);
    return acc;
  }, {});
}, "se_TagMap");
var se_TagQueueRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    QueueUrl: import_core2._toStr,
    Tags: (_) => se_TagMap(_, context)
  });
}, "se_TagQueueRequest");
var se_UntagQueueRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    QueueUrl: import_core2._toStr,
    TagKeys: (_) => se_TagKeyList(_, context)
  });
}, "se_UntagQueueRequest");
var de_BinaryList = /* @__PURE__ */ __name((output, context) => {
  const retVal = (output || []).filter((e) => e != null).map((entry) => {
    return context.base64Decoder(entry);
  });
  return retVal;
}, "de_BinaryList");
var de_Message = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    Attributes: import_smithy_client._json,
    Body: import_smithy_client.expectString,
    MD5OfBody: import_smithy_client.expectString,
    MD5OfMessageAttributes: import_smithy_client.expectString,
    MessageAttributes: (_) => de_MessageBodyAttributeMap(_, context),
    MessageId: import_smithy_client.expectString,
    ReceiptHandle: import_smithy_client.expectString
  });
}, "de_Message");
var de_MessageAttributeValue = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    BinaryListValues: (_) => de_BinaryList(_, context),
    BinaryValue: context.base64Decoder,
    DataType: import_smithy_client.expectString,
    StringListValues: import_smithy_client._json,
    StringValue: import_smithy_client.expectString
  });
}, "de_MessageAttributeValue");
var de_MessageBodyAttributeMap = /* @__PURE__ */ __name((output, context) => {
  return Object.entries(output).reduce((acc, [key, value]) => {
    if (value === null) {
      return acc;
    }
    acc[key] = de_MessageAttributeValue(value, context);
    return acc;
  }, {});
}, "de_MessageBodyAttributeMap");
var de_MessageList = /* @__PURE__ */ __name((output, context) => {
  const retVal = (output || []).filter((e) => e != null).map((entry) => {
    return de_Message(entry, context);
  });
  return retVal;
}, "de_MessageList");
var de_ReceiveMessageResult = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    Messages: (_) => de_MessageList(_, context)
  });
}, "de_ReceiveMessageResult");
var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
  httpStatusCode: output.statusCode,
  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
  extendedRequestId: output.headers["x-amz-id-2"],
  cfId: output.headers["x-amz-cf-id"]
}), "deserializeMetadata");
var throwDefaultError = (0, import_smithy_client.withBaseException)(SQSServiceException);
var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
  const contents = {
    protocol,
    hostname,
    port,
    method: "POST",
    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
    headers
  };
  if (resolvedHostname !== void 0) {
    contents.hostname = resolvedHostname;
  }
  if (body !== void 0) {
    contents.body = body;
  }
  return new import_protocol_http.HttpRequest(contents);
}, "buildHttpRpcRequest");
function sharedHeaders(operation) {
  return {
    "content-type": "application/x-amz-json-1.0",
    "x-amz-target": `AmazonSQS.${operation}`
  };
}
__name(sharedHeaders, "sharedHeaders");
var populateBodyWithQueryCompatibility = /* @__PURE__ */ __name((parsedOutput, headers) => {
  const queryErrorHeader = headers["x-amzn-query-error"];
  if (parsedOutput.body !== void 0 && queryErrorHeader != null) {
    const codeAndType = queryErrorHeader.split(";");
    parsedOutput.body.Code = codeAndType[0];
    parsedOutput.body.Type = codeAndType[1];
  }
}, "populateBodyWithQueryCompatibility");

// src/commands/AddPermissionCommand.ts
var _AddPermissionCommand = class _AddPermissionCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "AddPermission", {}).n("SQSClient", "AddPermissionCommand").f(void 0, void 0).ser(se_AddPermissionCommand).de(de_AddPermissionCommand).build() {
};
__name(_AddPermissionCommand, "AddPermissionCommand");
var AddPermissionCommand = _AddPermissionCommand;

// src/commands/CancelMessageMoveTaskCommand.ts



var _CancelMessageMoveTaskCommand = class _CancelMessageMoveTaskCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "CancelMessageMoveTask", {}).n("SQSClient", "CancelMessageMoveTaskCommand").f(void 0, void 0).ser(se_CancelMessageMoveTaskCommand).de(de_CancelMessageMoveTaskCommand).build() {
};
__name(_CancelMessageMoveTaskCommand, "CancelMessageMoveTaskCommand");
var CancelMessageMoveTaskCommand = _CancelMessageMoveTaskCommand;

// src/commands/ChangeMessageVisibilityBatchCommand.ts



var _ChangeMessageVisibilityBatchCommand = class _ChangeMessageVisibilityBatchCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "ChangeMessageVisibilityBatch", {}).n("SQSClient", "ChangeMessageVisibilityBatchCommand").f(void 0, void 0).ser(se_ChangeMessageVisibilityBatchCommand).de(de_ChangeMessageVisibilityBatchCommand).build() {
};
__name(_ChangeMessageVisibilityBatchCommand, "ChangeMessageVisibilityBatchCommand");
var ChangeMessageVisibilityBatchCommand = _ChangeMessageVisibilityBatchCommand;

// src/commands/ChangeMessageVisibilityCommand.ts



var _ChangeMessageVisibilityCommand = class _ChangeMessageVisibilityCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "ChangeMessageVisibility", {}).n("SQSClient", "ChangeMessageVisibilityCommand").f(void 0, void 0).ser(se_ChangeMessageVisibilityCommand).de(de_ChangeMessageVisibilityCommand).build() {
};
__name(_ChangeMessageVisibilityCommand, "ChangeMessageVisibilityCommand");
var ChangeMessageVisibilityCommand = _ChangeMessageVisibilityCommand;

// src/commands/CreateQueueCommand.ts



var _CreateQueueCommand = class _CreateQueueCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "CreateQueue", {}).n("SQSClient", "CreateQueueCommand").f(void 0, void 0).ser(se_CreateQueueCommand).de(de_CreateQueueCommand).build() {
};
__name(_CreateQueueCommand, "CreateQueueCommand");
var CreateQueueCommand = _CreateQueueCommand;

// src/commands/DeleteMessageBatchCommand.ts



var _DeleteMessageBatchCommand = class _DeleteMessageBatchCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "DeleteMessageBatch", {}).n("SQSClient", "DeleteMessageBatchCommand").f(void 0, void 0).ser(se_DeleteMessageBatchCommand).de(de_DeleteMessageBatchCommand).build() {
};
__name(_DeleteMessageBatchCommand, "DeleteMessageBatchCommand");
var DeleteMessageBatchCommand = _DeleteMessageBatchCommand;

// src/commands/DeleteMessageCommand.ts



var _DeleteMessageCommand = class _DeleteMessageCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "DeleteMessage", {}).n("SQSClient", "DeleteMessageCommand").f(void 0, void 0).ser(se_DeleteMessageCommand).de(de_DeleteMessageCommand).build() {
};
__name(_DeleteMessageCommand, "DeleteMessageCommand");
var DeleteMessageCommand = _DeleteMessageCommand;

// src/commands/DeleteQueueCommand.ts



var _DeleteQueueCommand = class _DeleteQueueCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "DeleteQueue", {}).n("SQSClient", "DeleteQueueCommand").f(void 0, void 0).ser(se_DeleteQueueCommand).de(de_DeleteQueueCommand).build() {
};
__name(_DeleteQueueCommand, "DeleteQueueCommand");
var DeleteQueueCommand = _DeleteQueueCommand;

// src/commands/GetQueueAttributesCommand.ts



var _GetQueueAttributesCommand = class _GetQueueAttributesCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "GetQueueAttributes", {}).n("SQSClient", "GetQueueAttributesCommand").f(void 0, void 0).ser(se_GetQueueAttributesCommand).de(de_GetQueueAttributesCommand).build() {
};
__name(_GetQueueAttributesCommand, "GetQueueAttributesCommand");
var GetQueueAttributesCommand = _GetQueueAttributesCommand;

// src/commands/GetQueueUrlCommand.ts



var _GetQueueUrlCommand = class _GetQueueUrlCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "GetQueueUrl", {}).n("SQSClient", "GetQueueUrlCommand").f(void 0, void 0).ser(se_GetQueueUrlCommand).de(de_GetQueueUrlCommand).build() {
};
__name(_GetQueueUrlCommand, "GetQueueUrlCommand");
var GetQueueUrlCommand = _GetQueueUrlCommand;

// src/commands/ListDeadLetterSourceQueuesCommand.ts



var _ListDeadLetterSourceQueuesCommand = class _ListDeadLetterSourceQueuesCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "ListDeadLetterSourceQueues", {}).n("SQSClient", "ListDeadLetterSourceQueuesCommand").f(void 0, void 0).ser(se_ListDeadLetterSourceQueuesCommand).de(de_ListDeadLetterSourceQueuesCommand).build() {
};
__name(_ListDeadLetterSourceQueuesCommand, "ListDeadLetterSourceQueuesCommand");
var ListDeadLetterSourceQueuesCommand = _ListDeadLetterSourceQueuesCommand;

// src/commands/ListMessageMoveTasksCommand.ts



var _ListMessageMoveTasksCommand = class _ListMessageMoveTasksCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "ListMessageMoveTasks", {}).n("SQSClient", "ListMessageMoveTasksCommand").f(void 0, void 0).ser(se_ListMessageMoveTasksCommand).de(de_ListMessageMoveTasksCommand).build() {
};
__name(_ListMessageMoveTasksCommand, "ListMessageMoveTasksCommand");
var ListMessageMoveTasksCommand = _ListMessageMoveTasksCommand;

// src/commands/ListQueuesCommand.ts



var _ListQueuesCommand = class _ListQueuesCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "ListQueues", {}).n("SQSClient", "ListQueuesCommand").f(void 0, void 0).ser(se_ListQueuesCommand).de(de_ListQueuesCommand).build() {
};
__name(_ListQueuesCommand, "ListQueuesCommand");
var ListQueuesCommand = _ListQueuesCommand;

// src/commands/ListQueueTagsCommand.ts



var _ListQueueTagsCommand = class _ListQueueTagsCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "ListQueueTags", {}).n("SQSClient", "ListQueueTagsCommand").f(void 0, void 0).ser(se_ListQueueTagsCommand).de(de_ListQueueTagsCommand).build() {
};
__name(_ListQueueTagsCommand, "ListQueueTagsCommand");
var ListQueueTagsCommand = _ListQueueTagsCommand;

// src/commands/PurgeQueueCommand.ts



var _PurgeQueueCommand = class _PurgeQueueCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "PurgeQueue", {}).n("SQSClient", "PurgeQueueCommand").f(void 0, void 0).ser(se_PurgeQueueCommand).de(de_PurgeQueueCommand).build() {
};
__name(_PurgeQueueCommand, "PurgeQueueCommand");
var PurgeQueueCommand = _PurgeQueueCommand;

// src/commands/ReceiveMessageCommand.ts




var _ReceiveMessageCommand = class _ReceiveMessageCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()),
    (0, import_middleware_sdk_sqs.getReceiveMessagePlugin)(config)
  ];
}).s("AmazonSQS", "ReceiveMessage", {}).n("SQSClient", "ReceiveMessageCommand").f(void 0, void 0).ser(se_ReceiveMessageCommand).de(de_ReceiveMessageCommand).build() {
};
__name(_ReceiveMessageCommand, "ReceiveMessageCommand");
var ReceiveMessageCommand = _ReceiveMessageCommand;

// src/commands/RemovePermissionCommand.ts



var _RemovePermissionCommand = class _RemovePermissionCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "RemovePermission", {}).n("SQSClient", "RemovePermissionCommand").f(void 0, void 0).ser(se_RemovePermissionCommand).de(de_RemovePermissionCommand).build() {
};
__name(_RemovePermissionCommand, "RemovePermissionCommand");
var RemovePermissionCommand = _RemovePermissionCommand;

// src/commands/SendMessageBatchCommand.ts




var _SendMessageBatchCommand = class _SendMessageBatchCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()),
    (0, import_middleware_sdk_sqs.getSendMessageBatchPlugin)(config)
  ];
}).s("AmazonSQS", "SendMessageBatch", {}).n("SQSClient", "SendMessageBatchCommand").f(void 0, void 0).ser(se_SendMessageBatchCommand).de(de_SendMessageBatchCommand).build() {
};
__name(_SendMessageBatchCommand, "SendMessageBatchCommand");
var SendMessageBatchCommand = _SendMessageBatchCommand;

// src/commands/SendMessageCommand.ts




var _SendMessageCommand = class _SendMessageCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()),
    (0, import_middleware_sdk_sqs.getSendMessagePlugin)(config)
  ];
}).s("AmazonSQS", "SendMessage", {}).n("SQSClient", "SendMessageCommand").f(void 0, void 0).ser(se_SendMessageCommand).de(de_SendMessageCommand).build() {
};
__name(_SendMessageCommand, "SendMessageCommand");
var SendMessageCommand = _SendMessageCommand;

// src/commands/SetQueueAttributesCommand.ts



var _SetQueueAttributesCommand = class _SetQueueAttributesCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "SetQueueAttributes", {}).n("SQSClient", "SetQueueAttributesCommand").f(void 0, void 0).ser(se_SetQueueAttributesCommand).de(de_SetQueueAttributesCommand).build() {
};
__name(_SetQueueAttributesCommand, "SetQueueAttributesCommand");
var SetQueueAttributesCommand = _SetQueueAttributesCommand;

// src/commands/StartMessageMoveTaskCommand.ts



var _StartMessageMoveTaskCommand = class _StartMessageMoveTaskCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "StartMessageMoveTask", {}).n("SQSClient", "StartMessageMoveTaskCommand").f(void 0, void 0).ser(se_StartMessageMoveTaskCommand).de(de_StartMessageMoveTaskCommand).build() {
};
__name(_StartMessageMoveTaskCommand, "StartMessageMoveTaskCommand");
var StartMessageMoveTaskCommand = _StartMessageMoveTaskCommand;

// src/commands/TagQueueCommand.ts



var _TagQueueCommand = class _TagQueueCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "TagQueue", {}).n("SQSClient", "TagQueueCommand").f(void 0, void 0).ser(se_TagQueueCommand).de(de_TagQueueCommand).build() {
};
__name(_TagQueueCommand, "TagQueueCommand");
var TagQueueCommand = _TagQueueCommand;

// src/commands/UntagQueueCommand.ts



var _UntagQueueCommand = class _UntagQueueCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AmazonSQS", "UntagQueue", {}).n("SQSClient", "UntagQueueCommand").f(void 0, void 0).ser(se_UntagQueueCommand).de(de_UntagQueueCommand).build() {
};
__name(_UntagQueueCommand, "UntagQueueCommand");
var UntagQueueCommand = _UntagQueueCommand;

// src/SQS.ts
var commands = {
  AddPermissionCommand,
  CancelMessageMoveTaskCommand,
  ChangeMessageVisibilityCommand,
  ChangeMessageVisibilityBatchCommand,
  CreateQueueCommand,
  DeleteMessageCommand,
  DeleteMessageBatchCommand,
  DeleteQueueCommand,
  GetQueueAttributesCommand,
  GetQueueUrlCommand,
  ListDeadLetterSourceQueuesCommand,
  ListMessageMoveTasksCommand,
  ListQueuesCommand,
  ListQueueTagsCommand,
  PurgeQueueCommand,
  ReceiveMessageCommand,
  RemovePermissionCommand,
  SendMessageCommand,
  SendMessageBatchCommand,
  SetQueueAttributesCommand,
  StartMessageMoveTaskCommand,
  TagQueueCommand,
  UntagQueueCommand
};
var _SQS = class _SQS extends SQSClient {
};
__name(_SQS, "SQS");
var SQS = _SQS;
(0, import_smithy_client.createAggregatedClient)(commands, SQS);

// src/pagination/ListDeadLetterSourceQueuesPaginator.ts

var paginateListDeadLetterSourceQueues = (0, import_core.createPaginator)(SQSClient, ListDeadLetterSourceQueuesCommand, "NextToken", "NextToken", "MaxResults");

// src/pagination/ListQueuesPaginator.ts

var paginateListQueues = (0, import_core.createPaginator)(SQSClient, ListQueuesCommand, "NextToken", "NextToken", "MaxResults");
// Annotate the CommonJS export names for ESM import in node:

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

