@aws-sdk/client-sqs 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3224 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SQSServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./SQSClient"), exports);
-tslib_1.__exportStar(require("./SQS"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var SQSServiceException_1 = require("./models/SQSServiceException");
-Object.defineProperty(exports, "SQSServiceException", { enumerable: true, get: function () { return SQSServiceException_1.SQSServiceException; } });
+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_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_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_5);
+    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    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_user_agent.getUserAgentPlugin)(this.config));
+    this.middlewareStack.use(
+      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
+        httpAuthSchemeParametersProvider: this.getDefaultHttpAuthSchemeParametersProvider(),
+        identityProviderConfigProvider: this.getIdentityProviderConfigProvider()
+      })
+    );
+    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();
+  }
+  getDefaultHttpAuthSchemeParametersProvider() {
+    return import_httpAuthSchemeProvider.defaultSQSHttpAuthSchemeParametersProvider;
+  }
+  getIdentityProviderConfigProvider() {
+    return async (config) => new import_core.DefaultIdentityProviderConfig({
+      "aws.auth#sigv4": config.credentials
+    });
+  }
+};
+__name(_SQSClient, "SQSClient");
+var SQSClient = _SQSClient;
+
+// src/SQS.ts
+
+
+// src/commands/AddPermissionCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// 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",
+  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_AddPermissionCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_AddPermissionCommand");
+var de_AddPermissionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AddPermissionCommandError");
+var de_CancelMessageMoveTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CancelMessageMoveTaskCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CancelMessageMoveTaskCommand");
+var de_CancelMessageMoveTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = 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 "RequestThrottled":
+    case "com.amazonaws.sqs#RequestThrottled":
+      throw await de_RequestThrottledRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sqs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperation":
+    case "com.amazonaws.sqs#UnsupportedOperation":
+      throw await de_UnsupportedOperationRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CancelMessageMoveTaskCommandError");
+var de_ChangeMessageVisibilityCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ChangeMessageVisibilityCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_ChangeMessageVisibilityCommand");
+var de_ChangeMessageVisibilityCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = 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 "MessageNotInflight":
+    case "com.amazonaws.sqs#MessageNotInflight":
+      throw await de_MessageNotInflightRes(parsedOutput, context);
+    case "QueueDoesNotExist":
+    case "com.amazonaws.sqs#QueueDoesNotExist":
+      throw await de_QueueDoesNotExistRes(parsedOutput, context);
+    case "ReceiptHandleIsInvalid":
+    case "com.amazonaws.sqs#ReceiptHandleIsInvalid":
+      throw await de_ReceiptHandleIsInvalidRes(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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ChangeMessageVisibilityCommandError");
+var de_ChangeMessageVisibilityBatchCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ChangeMessageVisibilityBatchCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ChangeMessageVisibilityBatchCommand");
+var de_ChangeMessageVisibilityBatchCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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 "InvalidAddress":
+    case "com.amazonaws.sqs#InvalidAddress":
+      throw await de_InvalidAddressRes(parsedOutput, context);
+    case "InvalidBatchEntryId":
+    case "com.amazonaws.sqs#InvalidBatchEntryId":
+      throw await de_InvalidBatchEntryIdRes(parsedOutput, context);
+    case "InvalidSecurity":
+    case "com.amazonaws.sqs#InvalidSecurity":
+      throw await de_InvalidSecurityRes(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 "TooManyEntriesInBatchRequest":
+    case "com.amazonaws.sqs#TooManyEntriesInBatchRequest":
+      throw await de_TooManyEntriesInBatchRequestRes(parsedOutput, context);
+    case "UnsupportedOperation":
+    case "com.amazonaws.sqs#UnsupportedOperation":
+      throw await de_UnsupportedOperationRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ChangeMessageVisibilityBatchCommandError");
+var de_CreateQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateQueueCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateQueueCommand");
+var de_CreateQueueCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidAddress":
+    case "com.amazonaws.sqs#InvalidAddress":
+      throw await de_InvalidAddressRes(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 "InvalidSecurity":
+    case "com.amazonaws.sqs#InvalidSecurity":
+      throw await de_InvalidSecurityRes(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 "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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateQueueCommandError");
+var de_DeleteMessageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteMessageCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeleteMessageCommand");
+var de_DeleteMessageCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidAddress":
+    case "com.amazonaws.sqs#InvalidAddress":
+      throw await de_InvalidAddressRes(parsedOutput, context);
+    case "InvalidIdFormat":
+    case "com.amazonaws.sqs#InvalidIdFormat":
+      throw await de_InvalidIdFormatRes(parsedOutput, context);
+    case "InvalidSecurity":
+    case "com.amazonaws.sqs#InvalidSecurity":
+      throw await de_InvalidSecurityRes(parsedOutput, context);
+    case "QueueDoesNotExist":
+    case "com.amazonaws.sqs#QueueDoesNotExist":
+      throw await de_QueueDoesNotExistRes(parsedOutput, context);
+    case "ReceiptHandleIsInvalid":
+    case "com.amazonaws.sqs#ReceiptHandleIsInvalid":
+      throw await de_ReceiptHandleIsInvalidRes(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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteMessageCommandError");
+var de_DeleteMessageBatchCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteMessageBatchCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteMessageBatchCommand");
+var de_DeleteMessageBatchCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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 "InvalidAddress":
+    case "com.amazonaws.sqs#InvalidAddress":
+      throw await de_InvalidAddressRes(parsedOutput, context);
+    case "InvalidBatchEntryId":
+    case "com.amazonaws.sqs#InvalidBatchEntryId":
+      throw await de_InvalidBatchEntryIdRes(parsedOutput, context);
+    case "InvalidSecurity":
+    case "com.amazonaws.sqs#InvalidSecurity":
+      throw await de_InvalidSecurityRes(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 "TooManyEntriesInBatchRequest":
+    case "com.amazonaws.sqs#TooManyEntriesInBatchRequest":
+      throw await de_TooManyEntriesInBatchRequestRes(parsedOutput, context);
+    case "UnsupportedOperation":
+    case "com.amazonaws.sqs#UnsupportedOperation":
+      throw await de_UnsupportedOperationRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteMessageBatchCommandError");
+var de_DeleteQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteQueueCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeleteQueueCommand");
+var de_DeleteQueueCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = 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 "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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteQueueCommandError");
+var de_GetQueueAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetQueueAttributesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetQueueAttributesCommand");
+var de_GetQueueAttributesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidAddress":
+    case "com.amazonaws.sqs#InvalidAddress":
+      throw await de_InvalidAddressRes(parsedOutput, context);
+    case "InvalidAttributeName":
+    case "com.amazonaws.sqs#InvalidAttributeName":
+      throw await de_InvalidAttributeNameRes(parsedOutput, context);
+    case "InvalidSecurity":
+    case "com.amazonaws.sqs#InvalidSecurity":
+      throw await de_InvalidSecurityRes(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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetQueueAttributesCommandError");
+var de_GetQueueUrlCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetQueueUrlCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetQueueUrlCommand");
+var de_GetQueueUrlCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = 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 "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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetQueueUrlCommandError");
+var de_ListDeadLetterSourceQueuesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListDeadLetterSourceQueuesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListDeadLetterSourceQueuesCommand");
+var de_ListDeadLetterSourceQueuesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = 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 "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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListDeadLetterSourceQueuesCommandError");
+var de_ListMessageMoveTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListMessageMoveTasksCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListMessageMoveTasksCommand");
+var de_ListMessageMoveTasksCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = 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 "RequestThrottled":
+    case "com.amazonaws.sqs#RequestThrottled":
+      throw await de_RequestThrottledRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sqs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperation":
+    case "com.amazonaws.sqs#UnsupportedOperation":
+      throw await de_UnsupportedOperationRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListMessageMoveTasksCommandError");
+var de_ListQueuesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListQueuesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListQueuesCommand");
+var de_ListQueuesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = 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 "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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListQueuesCommandError");
+var de_ListQueueTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListQueueTagsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListQueueTagsCommand");
+var de_ListQueueTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = 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 "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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListQueueTagsCommandError");
+var de_PurgeQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PurgeQueueCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_PurgeQueueCommand");
+var de_PurgeQueueCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = 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 "PurgeQueueInProgress":
+    case "com.amazonaws.sqs#PurgeQueueInProgress":
+      throw await de_PurgeQueueInProgressRes(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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PurgeQueueCommandError");
+var de_ReceiveMessageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ReceiveMessageCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ReceiveMessageResult(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ReceiveMessageCommand");
+var de_ReceiveMessageCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = 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 "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 "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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ReceiveMessageCommandError");
+var de_RemovePermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RemovePermissionCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_RemovePermissionCommand");
+var de_RemovePermissionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = 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 "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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RemovePermissionCommandError");
+var de_SendMessageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SendMessageCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SendMessageCommand");
+var de_SendMessageCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidAddress":
+    case "com.amazonaws.sqs#InvalidAddress":
+      throw await de_InvalidAddressRes(parsedOutput, context);
+    case "InvalidMessageContents":
+    case "com.amazonaws.sqs#InvalidMessageContents":
+      throw await de_InvalidMessageContentsRes(parsedOutput, context);
+    case "InvalidSecurity":
+    case "com.amazonaws.sqs#InvalidSecurity":
+      throw await de_InvalidSecurityRes(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 "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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SendMessageCommandError");
+var de_SendMessageBatchCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SendMessageBatchCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SendMessageBatchCommand");
+var de_SendMessageBatchCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BatchEntryIdsNotDistinct":
+    case "com.amazonaws.sqs#BatchEntryIdsNotDistinct":
+      throw await de_BatchEntryIdsNotDistinctRes(parsedOutput, context);
+    case "BatchRequestTooLong":
+    case "com.amazonaws.sqs#BatchRequestTooLong":
+      throw await de_BatchRequestTooLongRes(parsedOutput, context);
+    case "EmptyBatchRequest":
+    case "com.amazonaws.sqs#EmptyBatchRequest":
+      throw await de_EmptyBatchRequestRes(parsedOutput, context);
+    case "InvalidAddress":
+    case "com.amazonaws.sqs#InvalidAddress":
+      throw await de_InvalidAddressRes(parsedOutput, context);
+    case "InvalidBatchEntryId":
+    case "com.amazonaws.sqs#InvalidBatchEntryId":
+      throw await de_InvalidBatchEntryIdRes(parsedOutput, context);
+    case "InvalidSecurity":
+    case "com.amazonaws.sqs#InvalidSecurity":
+      throw await de_InvalidSecurityRes(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 "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 "TooManyEntriesInBatchRequest":
+    case "com.amazonaws.sqs#TooManyEntriesInBatchRequest":
+      throw await de_TooManyEntriesInBatchRequestRes(parsedOutput, context);
+    case "UnsupportedOperation":
+    case "com.amazonaws.sqs#UnsupportedOperation":
+      throw await de_UnsupportedOperationRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SendMessageBatchCommandError");
+var de_SetQueueAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SetQueueAttributesCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_SetQueueAttributesCommand");
+var de_SetQueueAttributesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidAddress":
+    case "com.amazonaws.sqs#InvalidAddress":
+      throw await de_InvalidAddressRes(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 "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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SetQueueAttributesCommandError");
+var de_StartMessageMoveTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartMessageMoveTaskCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartMessageMoveTaskCommand");
+var de_StartMessageMoveTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = 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 "RequestThrottled":
+    case "com.amazonaws.sqs#RequestThrottled":
+      throw await de_RequestThrottledRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sqs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedOperation":
+    case "com.amazonaws.sqs#UnsupportedOperation":
+      throw await de_UnsupportedOperationRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartMessageMoveTaskCommandError");
+var de_TagQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TagQueueCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_TagQueueCommand");
+var de_TagQueueCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = 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 "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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagQueueCommandError");
+var de_UntagQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UntagQueueCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_UntagQueueCommand");
+var de_UntagQueueCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
+  const errorCode = 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 "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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagQueueCommandError");
+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_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),
+    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 collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+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 parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+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 import_middleware_sdk_sqs = require("@aws-sdk/middleware-sdk-sqs");
+
+
+
+
+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");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddPermissionCommand,
+  BatchEntryIdsNotDistinct,
+  BatchRequestTooLong,
+  CancelMessageMoveTaskCommand,
+  ChangeMessageVisibilityBatchCommand,
+  ChangeMessageVisibilityCommand,
+  CreateQueueCommand,
+  DeleteMessageBatchCommand,
+  DeleteMessageCommand,
+  DeleteQueueCommand,
+  EmptyBatchRequest,
+  GetQueueAttributesCommand,
+  GetQueueUrlCommand,
+  InvalidAddress,
+  InvalidAttributeName,
+  InvalidAttributeValue,
+  InvalidBatchEntryId,
+  InvalidIdFormat,
+  InvalidMessageContents,
+  InvalidSecurity,
+  KmsAccessDenied,
+  KmsDisabled,
+  KmsInvalidKeyUsage,
+  KmsInvalidState,
+  KmsNotFound,
+  KmsOptInRequired,
+  KmsThrottled,
+  ListDeadLetterSourceQueuesCommand,
+  ListMessageMoveTasksCommand,
+  ListQueueTagsCommand,
+  ListQueuesCommand,
+  MessageNotInflight,
+  MessageSystemAttributeName,
+  MessageSystemAttributeNameForSends,
+  OverLimit,
+  PurgeQueueCommand,
+  PurgeQueueInProgress,
+  QueueAttributeName,
+  QueueDeletedRecently,
+  QueueDoesNotExist,
+  QueueNameExists,
+  ReceiptHandleIsInvalid,
+  ReceiveMessageCommand,
+  RemovePermissionCommand,
+  RequestThrottled,
+  ResourceNotFoundException,
+  SQS,
+  SQSClient,
+  SQSServiceException,
+  SendMessageBatchCommand,
+  SendMessageCommand,
+  SetQueueAttributesCommand,
+  StartMessageMoveTaskCommand,
+  TagQueueCommand,
+  TooManyEntriesInBatchRequest,
+  UnsupportedOperation,
+  UntagQueueCommand,
+  __Client,
+  paginateListDeadLetterSourceQueues,
+  paginateListQueues
+});