serverless-spy/node_modules/@aws-sdk/client-sqs/dist-cjs/index.js

CDK-based library for writing elegant integration tests on AWS serverless architecture and an additional web console to monitor events in real time.

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

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

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

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

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

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

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

// src/auth/httpAuthExtensionConfiguration.ts
var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
  let _credentials = runtimeConfig.credentials;
  return {
    setHttpAuthScheme(httpAuthScheme) {
      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
      if (index === -1) {
        _httpAuthSchemes.push(httpAuthScheme);
      } else {
        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
      }
    },
    httpAuthSchemes() {
      return _httpAuthSchemes;
    },
    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
      _httpAuthSchemeProvider = httpAuthSchemeProvider;
    },
    httpAuthSchemeProvider() {
      return _httpAuthSchemeProvider;
    },
    setCredentials(credentials) {
      _credentials = credentials;
    },
    credentials() {
      return _credentials;
    }
  };
}, "getHttpAuthExtensionConfiguration");
var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
  return {
    httpAuthSchemes: config.httpAuthSchemes(),
    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
    credentials: config.credentials()
  };
}, "resolveHttpAuthRuntimeConfig");

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

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

// src/SQS.ts


// src/commands/AddPermissionCommand.ts

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


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



// src/models/SQSServiceException.ts

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

// src/models/models_0.ts
var _InvalidAddress = class _InvalidAddress extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidAddress",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidAddress";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidAddress.prototype);
  }
};
__name(_InvalidAddress, "InvalidAddress");
var InvalidAddress = _InvalidAddress;
var _InvalidSecurity = class _InvalidSecurity extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidSecurity",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidSecurity";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidSecurity.prototype);
  }
};
__name(_InvalidSecurity, "InvalidSecurity");
var InvalidSecurity = _InvalidSecurity;
var _OverLimit = class _OverLimit extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "OverLimit",
      $fault: "client",
      ...opts
    });
    this.name = "OverLimit";
    this.$fault = "client";
    Object.setPrototypeOf(this, _OverLimit.prototype);
  }
};
__name(_OverLimit, "OverLimit");
var OverLimit = _OverLimit;
var _QueueDoesNotExist = class _QueueDoesNotExist extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "QueueDoesNotExist",
      $fault: "client",
      ...opts
    });
    this.name = "QueueDoesNotExist";
    this.$fault = "client";
    Object.setPrototypeOf(this, _QueueDoesNotExist.prototype);
  }
};
__name(_QueueDoesNotExist, "QueueDoesNotExist");
var QueueDoesNotExist = _QueueDoesNotExist;
var _RequestThrottled = class _RequestThrottled extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "RequestThrottled",
      $fault: "client",
      ...opts
    });
    this.name = "RequestThrottled";
    this.$fault = "client";
    Object.setPrototypeOf(this, _RequestThrottled.prototype);
  }
};
__name(_RequestThrottled, "RequestThrottled");
var RequestThrottled = _RequestThrottled;
var _UnsupportedOperation = class _UnsupportedOperation extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UnsupportedOperation",
      $fault: "client",
      ...opts
    });
    this.name = "UnsupportedOperation";
    this.$fault = "client";
    Object.setPrototypeOf(this, _UnsupportedOperation.prototype);
  }
};
__name(_UnsupportedOperation, "UnsupportedOperation");
var UnsupportedOperation = _UnsupportedOperation;
var _ResourceNotFoundException = class _ResourceNotFoundException extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "ResourceNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
  }
};
__name(_ResourceNotFoundException, "ResourceNotFoundException");
var ResourceNotFoundException = _ResourceNotFoundException;
var _MessageNotInflight = class _MessageNotInflight extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "MessageNotInflight",
      $fault: "client",
      ...opts
    });
    this.name = "MessageNotInflight";
    this.$fault = "client";
    Object.setPrototypeOf(this, _MessageNotInflight.prototype);
  }
};
__name(_MessageNotInflight, "MessageNotInflight");
var MessageNotInflight = _MessageNotInflight;
var _ReceiptHandleIsInvalid = class _ReceiptHandleIsInvalid extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ReceiptHandleIsInvalid",
      $fault: "client",
      ...opts
    });
    this.name = "ReceiptHandleIsInvalid";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ReceiptHandleIsInvalid.prototype);
  }
};
__name(_ReceiptHandleIsInvalid, "ReceiptHandleIsInvalid");
var ReceiptHandleIsInvalid = _ReceiptHandleIsInvalid;
var _BatchEntryIdsNotDistinct = class _BatchEntryIdsNotDistinct extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "BatchEntryIdsNotDistinct",
      $fault: "client",
      ...opts
    });
    this.name = "BatchEntryIdsNotDistinct";
    this.$fault = "client";
    Object.setPrototypeOf(this, _BatchEntryIdsNotDistinct.prototype);
  }
};
__name(_BatchEntryIdsNotDistinct, "BatchEntryIdsNotDistinct");
var BatchEntryIdsNotDistinct = _BatchEntryIdsNotDistinct;
var _EmptyBatchRequest = class _EmptyBatchRequest extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "EmptyBatchRequest",
      $fault: "client",
      ...opts
    });
    this.name = "EmptyBatchRequest";
    this.$fault = "client";
    Object.setPrototypeOf(this, _EmptyBatchRequest.prototype);
  }
};
__name(_EmptyBatchRequest, "EmptyBatchRequest");
var EmptyBatchRequest = _EmptyBatchRequest;
var _InvalidBatchEntryId = class _InvalidBatchEntryId extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidBatchEntryId",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidBatchEntryId";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidBatchEntryId.prototype);
  }
};
__name(_InvalidBatchEntryId, "InvalidBatchEntryId");
var InvalidBatchEntryId = _InvalidBatchEntryId;
var _TooManyEntriesInBatchRequest = class _TooManyEntriesInBatchRequest extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TooManyEntriesInBatchRequest",
      $fault: "client",
      ...opts
    });
    this.name = "TooManyEntriesInBatchRequest";
    this.$fault = "client";
    Object.setPrototypeOf(this, _TooManyEntriesInBatchRequest.prototype);
  }
};
__name(_TooManyEntriesInBatchRequest, "TooManyEntriesInBatchRequest");
var TooManyEntriesInBatchRequest = _TooManyEntriesInBatchRequest;
var QueueAttributeName = {
  All: "All",
  ApproximateNumberOfMessages: "ApproximateNumberOfMessages",
  ApproximateNumberOfMessagesDelayed: "ApproximateNumberOfMessagesDelayed",
  ApproximateNumberOfMessagesNotVisible: "ApproximateNumberOfMessagesNotVisible",
  ContentBasedDeduplication: "ContentBasedDeduplication",
  CreatedTimestamp: "CreatedTimestamp",
  DeduplicationScope: "DeduplicationScope",
  DelaySeconds: "DelaySeconds",
  FifoQueue: "FifoQueue",
  FifoThroughputLimit: "FifoThroughputLimit",
  KmsDataKeyReusePeriodSeconds: "KmsDataKeyReusePeriodSeconds",
  KmsMasterKeyId: "KmsMasterKeyId",
  LastModifiedTimestamp: "LastModifiedTimestamp",
  MaximumMessageSize: "MaximumMessageSize",
  MessageRetentionPeriod: "MessageRetentionPeriod",
  Policy: "Policy",
  QueueArn: "QueueArn",
  ReceiveMessageWaitTimeSeconds: "ReceiveMessageWaitTimeSeconds",
  RedriveAllowPolicy: "RedriveAllowPolicy",
  RedrivePolicy: "RedrivePolicy",
  SqsManagedSseEnabled: "SqsManagedSseEnabled",
  VisibilityTimeout: "VisibilityTimeout"
};
var _InvalidAttributeName = class _InvalidAttributeName extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidAttributeName",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidAttributeName";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidAttributeName.prototype);
  }
};
__name(_InvalidAttributeName, "InvalidAttributeName");
var InvalidAttributeName = _InvalidAttributeName;
var _InvalidAttributeValue = class _InvalidAttributeValue extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidAttributeValue",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidAttributeValue";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidAttributeValue.prototype);
  }
};
__name(_InvalidAttributeValue, "InvalidAttributeValue");
var InvalidAttributeValue = _InvalidAttributeValue;
var _QueueDeletedRecently = class _QueueDeletedRecently extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "QueueDeletedRecently",
      $fault: "client",
      ...opts
    });
    this.name = "QueueDeletedRecently";
    this.$fault = "client";
    Object.setPrototypeOf(this, _QueueDeletedRecently.prototype);
  }
};
__name(_QueueDeletedRecently, "QueueDeletedRecently");
var QueueDeletedRecently = _QueueDeletedRecently;
var _QueueNameExists = class _QueueNameExists extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "QueueNameExists",
      $fault: "client",
      ...opts
    });
    this.name = "QueueNameExists";
    this.$fault = "client";
    Object.setPrototypeOf(this, _QueueNameExists.prototype);
  }
};
__name(_QueueNameExists, "QueueNameExists");
var QueueNameExists = _QueueNameExists;
var _InvalidIdFormat = class _InvalidIdFormat extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidIdFormat",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidIdFormat";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidIdFormat.prototype);
  }
};
__name(_InvalidIdFormat, "InvalidIdFormat");
var InvalidIdFormat = _InvalidIdFormat;
var _PurgeQueueInProgress = class _PurgeQueueInProgress extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "PurgeQueueInProgress",
      $fault: "client",
      ...opts
    });
    this.name = "PurgeQueueInProgress";
    this.$fault = "client";
    Object.setPrototypeOf(this, _PurgeQueueInProgress.prototype);
  }
};
__name(_PurgeQueueInProgress, "PurgeQueueInProgress");
var PurgeQueueInProgress = _PurgeQueueInProgress;
var _KmsAccessDenied = class _KmsAccessDenied extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KmsAccessDenied",
      $fault: "client",
      ...opts
    });
    this.name = "KmsAccessDenied";
    this.$fault = "client";
    Object.setPrototypeOf(this, _KmsAccessDenied.prototype);
  }
};
__name(_KmsAccessDenied, "KmsAccessDenied");
var KmsAccessDenied = _KmsAccessDenied;
var _KmsDisabled = class _KmsDisabled extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KmsDisabled",
      $fault: "client",
      ...opts
    });
    this.name = "KmsDisabled";
    this.$fault = "client";
    Object.setPrototypeOf(this, _KmsDisabled.prototype);
  }
};
__name(_KmsDisabled, "KmsDisabled");
var KmsDisabled = _KmsDisabled;
var _KmsInvalidKeyUsage = class _KmsInvalidKeyUsage extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KmsInvalidKeyUsage",
      $fault: "client",
      ...opts
    });
    this.name = "KmsInvalidKeyUsage";
    this.$fault = "client";
    Object.setPrototypeOf(this, _KmsInvalidKeyUsage.prototype);
  }
};
__name(_KmsInvalidKeyUsage, "KmsInvalidKeyUsage");
var KmsInvalidKeyUsage = _KmsInvalidKeyUsage;
var _KmsInvalidState = class _KmsInvalidState extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KmsInvalidState",
      $fault: "client",
      ...opts
    });
    this.name = "KmsInvalidState";
    this.$fault = "client";
    Object.setPrototypeOf(this, _KmsInvalidState.prototype);
  }
};
__name(_KmsInvalidState, "KmsInvalidState");
var KmsInvalidState = _KmsInvalidState;
var _KmsNotFound = class _KmsNotFound extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KmsNotFound",
      $fault: "client",
      ...opts
    });
    this.name = "KmsNotFound";
    this.$fault = "client";
    Object.setPrototypeOf(this, _KmsNotFound.prototype);
  }
};
__name(_KmsNotFound, "KmsNotFound");
var KmsNotFound = _KmsNotFound;
var _KmsOptInRequired = class _KmsOptInRequired extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KmsOptInRequired",
      $fault: "client",
      ...opts
    });
    this.name = "KmsOptInRequired";
    this.$fault = "client";
    Object.setPrototypeOf(this, _KmsOptInRequired.prototype);
  }
};
__name(_KmsOptInRequired, "KmsOptInRequired");
var KmsOptInRequired = _KmsOptInRequired;
var _KmsThrottled = class _KmsThrottled extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "KmsThrottled",
      $fault: "client",
      ...opts
    });
    this.name = "KmsThrottled";
    this.$fault = "client";
    Object.setPrototypeOf(this, _KmsThrottled.prototype);
  }
};
__name(_KmsThrottled, "KmsThrottled");
var KmsThrottled = _KmsThrottled;
var MessageSystemAttributeName = {
  AWSTraceHeader: "AWSTraceHeader",
  All: "All",
  ApproximateFirstReceiveTimestamp: "ApproximateFirstReceiveTimestamp",
  ApproximateReceiveCount: "ApproximateReceiveCount",
  DeadLetterQueueSourceArn: "DeadLetterQueueSourceArn",
  MessageDeduplicationId: "MessageDeduplicationId",
  MessageGroupId: "MessageGroupId",
  SenderId: "SenderId",
  SentTimestamp: "SentTimestamp",
  SequenceNumber: "SequenceNumber"
};
var _InvalidMessageContents = class _InvalidMessageContents extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidMessageContents",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidMessageContents";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidMessageContents.prototype);
  }
};
__name(_InvalidMessageContents, "InvalidMessageContents");
var InvalidMessageContents = _InvalidMessageContents;
var MessageSystemAttributeNameForSends = {
  AWSTraceHeader: "AWSTraceHeader"
};
var _BatchRequestTooLong = class _BatchRequestTooLong extends SQSServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "BatchRequestTooLong",
      $fault: "client",
      ...opts
    });
    this.name = "BatchRequestTooLong";
    this.$fault = "client";
    Object.setPrototypeOf(this, _BatchRequestTooLong.prototype);
  }
};
__name(_BatchRequestTooLong, "BatchRequestTooLong");
var BatchRequestTooLong = _BatchRequestTooLong;

// src/protocols/Aws_json1_0.ts
var se_AddPermissionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("AddPermission");
  let body;
  body = JSON.stringify(se_AddPermissionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_AddPermissionCommand");
var se_CancelMessageMoveTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CancelMessageMoveTask");
  let body;
  body = JSON.stringify(se_CancelMessageMoveTaskRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CancelMessageMoveTaskCommand");
var se_ChangeMessageVisibilityCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ChangeMessageVisibility");
  let body;
  body = JSON.stringify(se_ChangeMessageVisibilityRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ChangeMessageVisibilityCommand");
var se_ChangeMessageVisibilityBatchCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ChangeMessageVisibilityBatch");
  let body;
  body = JSON.stringify(se_ChangeMessageVisibilityBatchRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ChangeMessageVisibilityBatchCommand");
var se_CreateQueueCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreateQueue");
  let body;
  body = JSON.stringify(se_CreateQueueRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreateQueueCommand");
var se_DeleteMessageCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteMessage");
  let body;
  body = JSON.stringify(se_DeleteMessageRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteMessageCommand");
var se_DeleteMessageBatchCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteMessageBatch");
  let body;
  body = JSON.stringify(se_DeleteMessageBatchRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteMessageBatchCommand");
var se_DeleteQueueCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteQueue");
  let body;
  body = JSON.stringify(se_DeleteQueueRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteQueueCommand");
var se_GetQueueAttributesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetQueueAttributes");
  let body;
  body = JSON.stringify(se_GetQueueAttributesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetQueueAttributesCommand");
var se_GetQueueUrlCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetQueueUrl");
  let body;
  body = JSON.stringify(se_GetQueueUrlRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetQueueUrlCommand");
var se_ListDeadLetterSourceQueuesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListDeadLetterSourceQueues");
  let body;
  body = JSON.stringify(se_ListDeadLetterSourceQueuesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListDeadLetterSourceQueuesCommand");
var se_ListMessageMoveTasksCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListMessageMoveTasks");
  let body;
  body = JSON.stringify(se_ListMessageMoveTasksRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListMessageMoveTasksCommand");
var se_ListQueuesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListQueues");
  let body;
  body = JSON.stringify(se_ListQueuesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListQueuesCommand");
var se_ListQueueTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListQueueTags");
  let body;
  body = JSON.stringify(se_ListQueueTagsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListQueueTagsCommand");
var se_PurgeQueueCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PurgeQueue");
  let body;
  body = JSON.stringify(se_PurgeQueueRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PurgeQueueCommand");
var se_ReceiveMessageCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ReceiveMessage");
  let body;
  body = JSON.stringify(se_ReceiveMessageRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ReceiveMessageCommand");
var se_RemovePermissionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("RemovePermission");
  let body;
  body = JSON.stringify(se_RemovePermissionRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_RemovePermissionCommand");
var se_SendMessageCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("SendMessage");
  let body;
  body = JSON.stringify(se_SendMessageRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_SendMessageCommand");
var se_SendMessageBatchCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("SendMessageBatch");
  let body;
  body = JSON.stringify(se_SendMessageBatchRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_SendMessageBatchCommand");
var se_SetQueueAttributesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("SetQueueAttributes");
  let body;
  body = JSON.stringify(se_SetQueueAttributesRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_SetQueueAttributesCommand");
var se_StartMessageMoveTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("StartMessageMoveTask");
  let body;
  body = JSON.stringify(se_StartMessageMoveTaskRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_StartMessageMoveTaskCommand");
var se_TagQueueCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("TagQueue");
  let body;
  body = JSON.stringify(se_TagQueueRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_TagQueueCommand");
var se_UntagQueueCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("UntagQueue");
  let body;
  body = JSON.stringify(se_UntagQueueRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_UntagQueueCommand");
var de_AddPermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_AddPermissionCommand");
var de_CancelMessageMoveTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_CancelMessageMoveTaskCommand");
var de_ChangeMessageVisibilityCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_ChangeMessageVisibilityCommand");
var de_ChangeMessageVisibilityBatchCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ChangeMessageVisibilityBatchCommand");
var de_CreateQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_CreateQueueCommand");
var de_DeleteMessageCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_DeleteMessageCommand");
var de_DeleteMessageBatchCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DeleteMessageBatchCommand");
var de_DeleteQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_DeleteQueueCommand");
var de_GetQueueAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_GetQueueAttributesCommand");
var de_GetQueueUrlCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_GetQueueUrlCommand");
var de_ListDeadLetterSourceQueuesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListDeadLetterSourceQueuesCommand");
var de_ListMessageMoveTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListMessageMoveTasksCommand");
var de_ListQueuesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListQueuesCommand");
var de_ListQueueTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListQueueTagsCommand");
var de_PurgeQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_PurgeQueueCommand");
var de_ReceiveMessageCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_ReceiveMessageResult(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ReceiveMessageCommand");
var de_RemovePermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_RemovePermissionCommand");
var de_SendMessageCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_SendMessageCommand");
var de_SendMessageBatchCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_SendMessageBatchCommand");
var de_SetQueueAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_SetQueueAttributesCommand");
var de_StartMessageMoveTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_StartMessageMoveTaskCommand");
var de_TagQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_TagQueueCommand");
var de_UntagQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_UntagQueueCommand");
var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
  const parsedOutput = {
    ...output,
    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
  };
  populateBodyWithQueryCompatibility(parsedOutput, output.headers);
  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
  switch (errorCode) {
    case "InvalidAddress":
    case "com.amazonaws.sqs#InvalidAddress":
      throw await de_InvalidAddressRes(parsedOutput, context);
    case "InvalidSecurity":
    case "com.amazonaws.sqs#InvalidSecurity":
      throw await de_InvalidSecurityRes(parsedOutput, context);
    case "OverLimit":
    case "com.amazonaws.sqs#OverLimit":
      throw await de_OverLimitRes(parsedOutput, context);
    case "QueueDoesNotExist":
    case "com.amazonaws.sqs#QueueDoesNotExist":
      throw await de_QueueDoesNotExistRes(parsedOutput, context);
    case "RequestThrottled":
    case "com.amazonaws.sqs#RequestThrottled":
      throw await de_RequestThrottledRes(parsedOutput, context);
    case "UnsupportedOperation":
    case "com.amazonaws.sqs#UnsupportedOperation":
      throw await de_UnsupportedOperationRes(parsedOutput, context);
    case "ResourceNotFoundException":
    case "com.amazonaws.sqs#ResourceNotFoundException":
      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
    case "MessageNotInflight":
    case "com.amazonaws.sqs#MessageNotInflight":
      throw await de_MessageNotInflightRes(parsedOutput, context);
    case "ReceiptHandleIsInvalid":
    case "com.amazonaws.sqs#ReceiptHandleIsInvalid":
      throw await de_ReceiptHandleIsInvalidRes(parsedOutput, context);
    case "BatchEntryIdsNotDistinct":
    case "com.amazonaws.sqs#BatchEntryIdsNotDistinct":
      throw await de_BatchEntryIdsNotDistinctRes(parsedOutput, context);
    case "EmptyBatchRequest":
    case "com.amazonaws.sqs#EmptyBatchRequest":
      throw await de_EmptyBatchRequestRes(parsedOutput, context);
    case "InvalidBatchEntryId":
    case "com.amazonaws.sqs#InvalidBatchEntryId":
      throw await de_InvalidBatchEntryIdRes(parsedOutput, context);
    case "TooManyEntriesInBatchRequest":
    case "com.amazonaws.sqs#TooManyEntriesInBatchRequest":
      throw await de_TooManyEntriesInBatchRequestRes(parsedOutput, context);
    case "InvalidAttributeName":
    case "com.amazonaws.sqs#InvalidAttributeName":
      throw await de_InvalidAttributeNameRes(parsedOutput, context);
    case "InvalidAttributeValue":
    case "com.amazonaws.sqs#InvalidAttributeValue":
      throw await de_InvalidAttributeValueRes(parsedOutput, context);
    case "QueueDeletedRecently":
    case "com.amazonaws.sqs#QueueDeletedRecently":
      throw await de_QueueDeletedRecentlyRes(parsedOutput, context);
    case "QueueNameExists":
    case "com.amazonaws.sqs#QueueNameExists":
      throw await de_QueueNameExistsRes(parsedOutput, context);
    case "InvalidIdFormat":
    case "com.amazonaws.sqs#InvalidIdFormat":
      throw await de_InvalidIdFormatRes(parsedOutput, context);
    case "PurgeQueueInProgress":
    case "com.amazonaws.sqs#PurgeQueueInProgress":
      throw await de_PurgeQueueInProgressRes(parsedOutput, context);
    case "KmsAccessDenied":
    case "com.amazonaws.sqs#KmsAccessDenied":
      throw await de_KmsAccessDeniedRes(parsedOutput, context);
    case "KmsDisabled":
    case "com.amazonaws.sqs#KmsDisabled":
      throw await de_KmsDisabledRes(parsedOutput, context);
    case "KmsInvalidKeyUsage":
    case "com.amazonaws.sqs#KmsInvalidKeyUsage":
      throw await de_KmsInvalidKeyUsageRes(parsedOutput, context);
    case "KmsInvalidState":
    case "com.amazonaws.sqs#KmsInvalidState":
      throw await de_KmsInvalidStateRes(parsedOutput, context);
    case "KmsNotFound":
    case "com.amazonaws.sqs#KmsNotFound":
      throw await de_KmsNotFoundRes(parsedOutput, context);
    case "KmsOptInRequired":
    case "com.amazonaws.sqs#KmsOptInRequired":
      throw await de_KmsOptInRequiredRes(parsedOutput, context);
    case "KmsThrottled":
    case "com.amazonaws.sqs#KmsThrottled":
      throw await de_KmsThrottledRes(parsedOutput, context);
    case "InvalidMessageContents":
    case "com.amazonaws.sqs#InvalidMessageContents":
      throw await de_InvalidMessageContentsRes(parsedOutput, context);
    case "BatchRequestTooLong":
    case "com.amazonaws.sqs#BatchRequestTooLong":
      throw await de_BatchRequestTooLongRes(parsedOutput, context);
    default:
      const parsedBody = parsedOutput.body;
      return throwDefaultError({
        output,
        parsedBody,
        errorCode
      });
  }
}, "de_CommandError");
var de_BatchEntryIdsNotDistinctRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new BatchEntryIdsNotDistinct({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_BatchEntryIdsNotDistinctRes");
var de_BatchRequestTooLongRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new BatchRequestTooLong({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_BatchRequestTooLongRes");
var de_EmptyBatchRequestRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new EmptyBatchRequest({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_EmptyBatchRequestRes");
var de_InvalidAddressRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new InvalidAddress({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidAddressRes");
var de_InvalidAttributeNameRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new InvalidAttributeName({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidAttributeNameRes");
var de_InvalidAttributeValueRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new InvalidAttributeValue({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidAttributeValueRes");
var de_InvalidBatchEntryIdRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedO