@aws-sdk/client-polly 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,1911 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PollyServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./PollyClient"), exports);
-tslib_1.__exportStar(require("./Polly"), 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 PollyServiceException_1 = require("./models/PollyServiceException");
-Object.defineProperty(exports, "PollyServiceException", { enumerable: true, get: function () { return PollyServiceException_1.PollyServiceException; } });
+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, {
+  DeleteLexiconCommand: () => DeleteLexiconCommand,
+  DescribeVoicesCommand: () => DescribeVoicesCommand,
+  Engine: () => Engine,
+  EngineNotSupportedException: () => EngineNotSupportedException,
+  Gender: () => Gender,
+  GetLexiconCommand: () => GetLexiconCommand,
+  GetLexiconOutputFilterSensitiveLog: () => GetLexiconOutputFilterSensitiveLog,
+  GetSpeechSynthesisTaskCommand: () => GetSpeechSynthesisTaskCommand,
+  InvalidLexiconException: () => InvalidLexiconException,
+  InvalidNextTokenException: () => InvalidNextTokenException,
+  InvalidS3BucketException: () => InvalidS3BucketException,
+  InvalidS3KeyException: () => InvalidS3KeyException,
+  InvalidSampleRateException: () => InvalidSampleRateException,
+  InvalidSnsTopicArnException: () => InvalidSnsTopicArnException,
+  InvalidSsmlException: () => InvalidSsmlException,
+  InvalidTaskIdException: () => InvalidTaskIdException,
+  LanguageCode: () => LanguageCode,
+  LanguageNotSupportedException: () => LanguageNotSupportedException,
+  LexiconFilterSensitiveLog: () => LexiconFilterSensitiveLog,
+  LexiconNotFoundException: () => LexiconNotFoundException,
+  LexiconSizeExceededException: () => LexiconSizeExceededException,
+  ListLexiconsCommand: () => ListLexiconsCommand,
+  ListSpeechSynthesisTasksCommand: () => ListSpeechSynthesisTasksCommand,
+  MarksNotSupportedForFormatException: () => MarksNotSupportedForFormatException,
+  MaxLexemeLengthExceededException: () => MaxLexemeLengthExceededException,
+  MaxLexiconsNumberExceededException: () => MaxLexiconsNumberExceededException,
+  OutputFormat: () => OutputFormat,
+  Polly: () => Polly,
+  PollyClient: () => PollyClient,
+  PollyServiceException: () => PollyServiceException,
+  PutLexiconCommand: () => PutLexiconCommand,
+  PutLexiconInputFilterSensitiveLog: () => PutLexiconInputFilterSensitiveLog,
+  ServiceFailureException: () => ServiceFailureException,
+  SpeechMarkType: () => SpeechMarkType,
+  SsmlMarksNotSupportedForTextTypeException: () => SsmlMarksNotSupportedForTextTypeException,
+  StartSpeechSynthesisTaskCommand: () => StartSpeechSynthesisTaskCommand,
+  SynthesisTaskNotFoundException: () => SynthesisTaskNotFoundException,
+  SynthesizeSpeechCommand: () => SynthesizeSpeechCommand,
+  SynthesizeSpeechOutputFilterSensitiveLog: () => SynthesizeSpeechOutputFilterSensitiveLog,
+  TaskStatus: () => TaskStatus,
+  TextLengthExceededException: () => TextLengthExceededException,
+  TextType: () => TextType,
+  UnsupportedPlsAlphabetException: () => UnsupportedPlsAlphabetException,
+  UnsupportedPlsLanguageException: () => UnsupportedPlsLanguageException,
+  VoiceId: () => VoiceId,
+  __Client: () => import_smithy_client.Client,
+  paginateListSpeechSynthesisTasks: () => paginateListSpeechSynthesisTasks
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/PollyClient.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: "polly"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/PollyClient.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/PollyClient.ts
+var _PollyClient = class _PollyClient 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.defaultPollyHttpAuthSchemeParametersProvider;
+  }
+  getIdentityProviderConfigProvider() {
+    return async (config) => new import_core.DefaultIdentityProviderConfig({
+      "aws.auth#sigv4": config.credentials
+    });
+  }
+};
+__name(_PollyClient, "PollyClient");
+var PollyClient = _PollyClient;
+
+// src/Polly.ts
+
+
+// src/commands/DeleteLexiconCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+
+
+
+// src/models/models_0.ts
+
+
+// src/models/PollyServiceException.ts
+
+var _PollyServiceException = class _PollyServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _PollyServiceException.prototype);
+  }
+};
+__name(_PollyServiceException, "PollyServiceException");
+var PollyServiceException = _PollyServiceException;
+
+// src/models/models_0.ts
+var _LexiconNotFoundException = class _LexiconNotFoundException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LexiconNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LexiconNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LexiconNotFoundException.prototype);
+  }
+};
+__name(_LexiconNotFoundException, "LexiconNotFoundException");
+var LexiconNotFoundException = _LexiconNotFoundException;
+var _ServiceFailureException = class _ServiceFailureException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceFailureException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "ServiceFailureException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _ServiceFailureException.prototype);
+  }
+};
+__name(_ServiceFailureException, "ServiceFailureException");
+var ServiceFailureException = _ServiceFailureException;
+var Engine = {
+  LONG_FORM: "long-form",
+  NEURAL: "neural",
+  STANDARD: "standard"
+};
+var LanguageCode = {
+  ar_AE: "ar-AE",
+  arb: "arb",
+  ca_ES: "ca-ES",
+  cmn_CN: "cmn-CN",
+  cy_GB: "cy-GB",
+  da_DK: "da-DK",
+  de_AT: "de-AT",
+  de_DE: "de-DE",
+  en_AU: "en-AU",
+  en_GB: "en-GB",
+  en_GB_WLS: "en-GB-WLS",
+  en_IE: "en-IE",
+  en_IN: "en-IN",
+  en_NZ: "en-NZ",
+  en_US: "en-US",
+  en_ZA: "en-ZA",
+  es_ES: "es-ES",
+  es_MX: "es-MX",
+  es_US: "es-US",
+  fi_FI: "fi-FI",
+  fr_BE: "fr-BE",
+  fr_CA: "fr-CA",
+  fr_FR: "fr-FR",
+  hi_IN: "hi-IN",
+  is_IS: "is-IS",
+  it_IT: "it-IT",
+  ja_JP: "ja-JP",
+  ko_KR: "ko-KR",
+  nb_NO: "nb-NO",
+  nl_BE: "nl-BE",
+  nl_NL: "nl-NL",
+  pl_PL: "pl-PL",
+  pt_BR: "pt-BR",
+  pt_PT: "pt-PT",
+  ro_RO: "ro-RO",
+  ru_RU: "ru-RU",
+  sv_SE: "sv-SE",
+  tr_TR: "tr-TR",
+  yue_CN: "yue-CN"
+};
+var Gender = {
+  Female: "Female",
+  Male: "Male"
+};
+var VoiceId = {
+  Aditi: "Aditi",
+  Adriano: "Adriano",
+  Amy: "Amy",
+  Andres: "Andres",
+  Aria: "Aria",
+  Arlet: "Arlet",
+  Arthur: "Arthur",
+  Astrid: "Astrid",
+  Ayanda: "Ayanda",
+  Bianca: "Bianca",
+  Brian: "Brian",
+  Camila: "Camila",
+  Carla: "Carla",
+  Carmen: "Carmen",
+  Celine: "Celine",
+  Chantal: "Chantal",
+  Conchita: "Conchita",
+  Cristiano: "Cristiano",
+  Daniel: "Daniel",
+  Danielle: "Danielle",
+  Dora: "Dora",
+  Elin: "Elin",
+  Emma: "Emma",
+  Enrique: "Enrique",
+  Ewa: "Ewa",
+  Filiz: "Filiz",
+  Gabrielle: "Gabrielle",
+  Geraint: "Geraint",
+  Giorgio: "Giorgio",
+  Gregory: "Gregory",
+  Gwyneth: "Gwyneth",
+  Hala: "Hala",
+  Hannah: "Hannah",
+  Hans: "Hans",
+  Hiujin: "Hiujin",
+  Ida: "Ida",
+  Ines: "Ines",
+  Isabelle: "Isabelle",
+  Ivy: "Ivy",
+  Jacek: "Jacek",
+  Jan: "Jan",
+  Joanna: "Joanna",
+  Joey: "Joey",
+  Justin: "Justin",
+  Kajal: "Kajal",
+  Karl: "Karl",
+  Kazuha: "Kazuha",
+  Kendra: "Kendra",
+  Kevin: "Kevin",
+  Kimberly: "Kimberly",
+  Laura: "Laura",
+  Lea: "Lea",
+  Liam: "Liam",
+  Lisa: "Lisa",
+  Liv: "Liv",
+  Lotte: "Lotte",
+  Lucia: "Lucia",
+  Lupe: "Lupe",
+  Mads: "Mads",
+  Maja: "Maja",
+  Marlene: "Marlene",
+  Mathieu: "Mathieu",
+  Matthew: "Matthew",
+  Maxim: "Maxim",
+  Mia: "Mia",
+  Miguel: "Miguel",
+  Mizuki: "Mizuki",
+  Naja: "Naja",
+  Niamh: "Niamh",
+  Nicole: "Nicole",
+  Ola: "Ola",
+  Olivia: "Olivia",
+  Pedro: "Pedro",
+  Penelope: "Penelope",
+  Raveena: "Raveena",
+  Remi: "Remi",
+  Ricardo: "Ricardo",
+  Ruben: "Ruben",
+  Russell: "Russell",
+  Ruth: "Ruth",
+  Salli: "Salli",
+  Seoyeon: "Seoyeon",
+  Sergio: "Sergio",
+  Sofie: "Sofie",
+  Stephen: "Stephen",
+  Suvi: "Suvi",
+  Takumi: "Takumi",
+  Tatyana: "Tatyana",
+  Thiago: "Thiago",
+  Tomoko: "Tomoko",
+  Vicki: "Vicki",
+  Vitoria: "Vitoria",
+  Zayd: "Zayd",
+  Zeina: "Zeina",
+  Zhiyu: "Zhiyu"
+};
+var _InvalidNextTokenException = class _InvalidNextTokenException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidNextTokenException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidNextTokenException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidNextTokenException.prototype);
+  }
+};
+__name(_InvalidNextTokenException, "InvalidNextTokenException");
+var InvalidNextTokenException = _InvalidNextTokenException;
+var _EngineNotSupportedException = class _EngineNotSupportedException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "EngineNotSupportedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "EngineNotSupportedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _EngineNotSupportedException.prototype);
+  }
+};
+__name(_EngineNotSupportedException, "EngineNotSupportedException");
+var EngineNotSupportedException = _EngineNotSupportedException;
+var OutputFormat = {
+  JSON: "json",
+  MP3: "mp3",
+  OGG_VORBIS: "ogg_vorbis",
+  PCM: "pcm"
+};
+var SpeechMarkType = {
+  SENTENCE: "sentence",
+  SSML: "ssml",
+  VISEME: "viseme",
+  WORD: "word"
+};
+var TaskStatus = {
+  COMPLETED: "completed",
+  FAILED: "failed",
+  IN_PROGRESS: "inProgress",
+  SCHEDULED: "scheduled"
+};
+var TextType = {
+  SSML: "ssml",
+  TEXT: "text"
+};
+var _InvalidTaskIdException = class _InvalidTaskIdException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidTaskIdException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidTaskIdException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidTaskIdException.prototype);
+  }
+};
+__name(_InvalidTaskIdException, "InvalidTaskIdException");
+var InvalidTaskIdException = _InvalidTaskIdException;
+var _SynthesisTaskNotFoundException = class _SynthesisTaskNotFoundException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "SynthesisTaskNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "SynthesisTaskNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _SynthesisTaskNotFoundException.prototype);
+  }
+};
+__name(_SynthesisTaskNotFoundException, "SynthesisTaskNotFoundException");
+var SynthesisTaskNotFoundException = _SynthesisTaskNotFoundException;
+var _InvalidLexiconException = class _InvalidLexiconException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidLexiconException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidLexiconException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidLexiconException.prototype);
+  }
+};
+__name(_InvalidLexiconException, "InvalidLexiconException");
+var InvalidLexiconException = _InvalidLexiconException;
+var _InvalidS3BucketException = class _InvalidS3BucketException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidS3BucketException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidS3BucketException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidS3BucketException.prototype);
+  }
+};
+__name(_InvalidS3BucketException, "InvalidS3BucketException");
+var InvalidS3BucketException = _InvalidS3BucketException;
+var _InvalidS3KeyException = class _InvalidS3KeyException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidS3KeyException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidS3KeyException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidS3KeyException.prototype);
+  }
+};
+__name(_InvalidS3KeyException, "InvalidS3KeyException");
+var InvalidS3KeyException = _InvalidS3KeyException;
+var _InvalidSampleRateException = class _InvalidSampleRateException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidSampleRateException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidSampleRateException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidSampleRateException.prototype);
+  }
+};
+__name(_InvalidSampleRateException, "InvalidSampleRateException");
+var InvalidSampleRateException = _InvalidSampleRateException;
+var _InvalidSnsTopicArnException = class _InvalidSnsTopicArnException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidSnsTopicArnException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidSnsTopicArnException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidSnsTopicArnException.prototype);
+  }
+};
+__name(_InvalidSnsTopicArnException, "InvalidSnsTopicArnException");
+var InvalidSnsTopicArnException = _InvalidSnsTopicArnException;
+var _InvalidSsmlException = class _InvalidSsmlException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidSsmlException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidSsmlException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidSsmlException.prototype);
+  }
+};
+__name(_InvalidSsmlException, "InvalidSsmlException");
+var InvalidSsmlException = _InvalidSsmlException;
+var _LanguageNotSupportedException = class _LanguageNotSupportedException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LanguageNotSupportedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LanguageNotSupportedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LanguageNotSupportedException.prototype);
+  }
+};
+__name(_LanguageNotSupportedException, "LanguageNotSupportedException");
+var LanguageNotSupportedException = _LanguageNotSupportedException;
+var _LexiconSizeExceededException = class _LexiconSizeExceededException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LexiconSizeExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LexiconSizeExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LexiconSizeExceededException.prototype);
+  }
+};
+__name(_LexiconSizeExceededException, "LexiconSizeExceededException");
+var LexiconSizeExceededException = _LexiconSizeExceededException;
+var _MarksNotSupportedForFormatException = class _MarksNotSupportedForFormatException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "MarksNotSupportedForFormatException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "MarksNotSupportedForFormatException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _MarksNotSupportedForFormatException.prototype);
+  }
+};
+__name(_MarksNotSupportedForFormatException, "MarksNotSupportedForFormatException");
+var MarksNotSupportedForFormatException = _MarksNotSupportedForFormatException;
+var _MaxLexemeLengthExceededException = class _MaxLexemeLengthExceededException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "MaxLexemeLengthExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "MaxLexemeLengthExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _MaxLexemeLengthExceededException.prototype);
+  }
+};
+__name(_MaxLexemeLengthExceededException, "MaxLexemeLengthExceededException");
+var MaxLexemeLengthExceededException = _MaxLexemeLengthExceededException;
+var _MaxLexiconsNumberExceededException = class _MaxLexiconsNumberExceededException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "MaxLexiconsNumberExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "MaxLexiconsNumberExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _MaxLexiconsNumberExceededException.prototype);
+  }
+};
+__name(_MaxLexiconsNumberExceededException, "MaxLexiconsNumberExceededException");
+var MaxLexiconsNumberExceededException = _MaxLexiconsNumberExceededException;
+var _UnsupportedPlsAlphabetException = class _UnsupportedPlsAlphabetException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnsupportedPlsAlphabetException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnsupportedPlsAlphabetException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnsupportedPlsAlphabetException.prototype);
+  }
+};
+__name(_UnsupportedPlsAlphabetException, "UnsupportedPlsAlphabetException");
+var UnsupportedPlsAlphabetException = _UnsupportedPlsAlphabetException;
+var _UnsupportedPlsLanguageException = class _UnsupportedPlsLanguageException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnsupportedPlsLanguageException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnsupportedPlsLanguageException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnsupportedPlsLanguageException.prototype);
+  }
+};
+__name(_UnsupportedPlsLanguageException, "UnsupportedPlsLanguageException");
+var UnsupportedPlsLanguageException = _UnsupportedPlsLanguageException;
+var _SsmlMarksNotSupportedForTextTypeException = class _SsmlMarksNotSupportedForTextTypeException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "SsmlMarksNotSupportedForTextTypeException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "SsmlMarksNotSupportedForTextTypeException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _SsmlMarksNotSupportedForTextTypeException.prototype);
+  }
+};
+__name(_SsmlMarksNotSupportedForTextTypeException, "SsmlMarksNotSupportedForTextTypeException");
+var SsmlMarksNotSupportedForTextTypeException = _SsmlMarksNotSupportedForTextTypeException;
+var _TextLengthExceededException = class _TextLengthExceededException extends PollyServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TextLengthExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TextLengthExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TextLengthExceededException.prototype);
+  }
+};
+__name(_TextLengthExceededException, "TextLengthExceededException");
+var TextLengthExceededException = _TextLengthExceededException;
+var LexiconFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Content && { Content: import_smithy_client.SENSITIVE_STRING }
+}), "LexiconFilterSensitiveLog");
+var GetLexiconOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Lexicon && { Lexicon: LexiconFilterSensitiveLog(obj.Lexicon) }
+}), "GetLexiconOutputFilterSensitiveLog");
+var PutLexiconInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Content && { Content: import_smithy_client.SENSITIVE_STRING }
+}), "PutLexiconInputFilterSensitiveLog");
+var SynthesizeSpeechOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "SynthesizeSpeechOutputFilterSensitiveLog");
+
+// src/protocols/Aws_restJson1.ts
+var se_DeleteLexiconCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/lexicons/{Name}");
+  b.p("Name", () => input.Name, "{Name}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteLexiconCommand");
+var se_DescribeVoicesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/voices");
+  const query = (0, import_smithy_client.map)({
+    [_E]: [, input[_E]],
+    [_LC]: [, input[_LC]],
+    [_IALC]: [() => input.IncludeAdditionalLanguageCodes !== void 0, () => input[_IALC].toString()],
+    [_NT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DescribeVoicesCommand");
+var se_GetLexiconCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/lexicons/{Name}");
+  b.p("Name", () => input.Name, "{Name}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetLexiconCommand");
+var se_GetSpeechSynthesisTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/synthesisTasks/{TaskId}");
+  b.p("TaskId", () => input.TaskId, "{TaskId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetSpeechSynthesisTaskCommand");
+var se_ListLexiconsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/lexicons");
+  const query = (0, import_smithy_client.map)({
+    [_NT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListLexiconsCommand");
+var se_ListSpeechSynthesisTasksCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/synthesisTasks");
+  const query = (0, import_smithy_client.map)({
+    [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_NT]: [, input[_NT]],
+    [_S]: [, input[_S]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListSpeechSynthesisTasksCommand");
+var se_PutLexiconCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/lexicons/{Name}");
+  b.p("Name", () => input.Name, "{Name}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Content: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_PutLexiconCommand");
+var se_StartSpeechSynthesisTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/synthesisTasks");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Engine: [],
+      LanguageCode: [],
+      LexiconNames: (_) => (0, import_smithy_client._json)(_),
+      OutputFormat: [],
+      OutputS3BucketName: [],
+      OutputS3KeyPrefix: [],
+      SampleRate: [],
+      SnsTopicArn: [],
+      SpeechMarkTypes: (_) => (0, import_smithy_client._json)(_),
+      Text: [],
+      TextType: [],
+      VoiceId: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartSpeechSynthesisTaskCommand");
+var se_SynthesizeSpeechCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/speech");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Engine: [],
+      LanguageCode: [],
+      LexiconNames: (_) => (0, import_smithy_client._json)(_),
+      OutputFormat: [],
+      SampleRate: [],
+      SpeechMarkTypes: (_) => (0, import_smithy_client._json)(_),
+      Text: [],
+      TextType: [],
+      VoiceId: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_SynthesizeSpeechCommand");
+var de_DeleteLexiconCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteLexiconCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteLexiconCommand");
+var de_DeleteLexiconCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LexiconNotFoundException":
+    case "com.amazonaws.polly#LexiconNotFoundException":
+      throw await de_LexiconNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceFailureException":
+    case "com.amazonaws.polly#ServiceFailureException":
+      throw await de_ServiceFailureExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteLexiconCommandError");
+var de_DescribeVoicesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeVoicesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    Voices: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeVoicesCommand");
+var de_DescribeVoicesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidNextTokenException":
+    case "com.amazonaws.polly#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "ServiceFailureException":
+    case "com.amazonaws.polly#ServiceFailureException":
+      throw await de_ServiceFailureExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeVoicesCommandError");
+var de_GetLexiconCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetLexiconCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Lexicon: import_smithy_client._json,
+    LexiconAttributes: (_) => de_LexiconAttributes(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetLexiconCommand");
+var de_GetLexiconCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LexiconNotFoundException":
+    case "com.amazonaws.polly#LexiconNotFoundException":
+      throw await de_LexiconNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceFailureException":
+    case "com.amazonaws.polly#ServiceFailureException":
+      throw await de_ServiceFailureExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetLexiconCommandError");
+var de_GetSpeechSynthesisTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetSpeechSynthesisTaskCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    SynthesisTask: (_) => de_SynthesisTask(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetSpeechSynthesisTaskCommand");
+var de_GetSpeechSynthesisTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidTaskIdException":
+    case "com.amazonaws.polly#InvalidTaskIdException":
+      throw await de_InvalidTaskIdExceptionRes(parsedOutput, context);
+    case "ServiceFailureException":
+    case "com.amazonaws.polly#ServiceFailureException":
+      throw await de_ServiceFailureExceptionRes(parsedOutput, context);
+    case "SynthesisTaskNotFoundException":
+    case "com.amazonaws.polly#SynthesisTaskNotFoundException":
+      throw await de_SynthesisTaskNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetSpeechSynthesisTaskCommandError");
+var de_ListLexiconsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListLexiconsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Lexicons: (_) => de_LexiconDescriptionList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListLexiconsCommand");
+var de_ListLexiconsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidNextTokenException":
+    case "com.amazonaws.polly#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "ServiceFailureException":
+    case "com.amazonaws.polly#ServiceFailureException":
+      throw await de_ServiceFailureExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListLexiconsCommandError");
+var de_ListSpeechSynthesisTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListSpeechSynthesisTasksCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    SynthesisTasks: (_) => de_SynthesisTasks(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListSpeechSynthesisTasksCommand");
+var de_ListSpeechSynthesisTasksCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidNextTokenException":
+    case "com.amazonaws.polly#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "ServiceFailureException":
+    case "com.amazonaws.polly#ServiceFailureException":
+      throw await de_ServiceFailureExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListSpeechSynthesisTasksCommandError");
+var de_PutLexiconCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_PutLexiconCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_PutLexiconCommand");
+var de_PutLexiconCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidLexiconException":
+    case "com.amazonaws.polly#InvalidLexiconException":
+      throw await de_InvalidLexiconExceptionRes(parsedOutput, context);
+    case "LexiconSizeExceededException":
+    case "com.amazonaws.polly#LexiconSizeExceededException":
+      throw await de_LexiconSizeExceededExceptionRes(parsedOutput, context);
+    case "MaxLexemeLengthExceededException":
+    case "com.amazonaws.polly#MaxLexemeLengthExceededException":
+      throw await de_MaxLexemeLengthExceededExceptionRes(parsedOutput, context);
+    case "MaxLexiconsNumberExceededException":
+    case "com.amazonaws.polly#MaxLexiconsNumberExceededException":
+      throw await de_MaxLexiconsNumberExceededExceptionRes(parsedOutput, context);
+    case "ServiceFailureException":
+    case "com.amazonaws.polly#ServiceFailureException":
+      throw await de_ServiceFailureExceptionRes(parsedOutput, context);
+    case "UnsupportedPlsAlphabetException":
+    case "com.amazonaws.polly#UnsupportedPlsAlphabetException":
+      throw await de_UnsupportedPlsAlphabetExceptionRes(parsedOutput, context);
+    case "UnsupportedPlsLanguageException":
+    case "com.amazonaws.polly#UnsupportedPlsLanguageException":
+      throw await de_UnsupportedPlsLanguageExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutLexiconCommandError");
+var de_StartSpeechSynthesisTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartSpeechSynthesisTaskCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    SynthesisTask: (_) => de_SynthesisTask(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StartSpeechSynthesisTaskCommand");
+var de_StartSpeechSynthesisTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "EngineNotSupportedException":
+    case "com.amazonaws.polly#EngineNotSupportedException":
+      throw await de_EngineNotSupportedExceptionRes(parsedOutput, context);
+    case "InvalidS3BucketException":
+    case "com.amazonaws.polly#InvalidS3BucketException":
+      throw await de_InvalidS3BucketExceptionRes(parsedOutput, context);
+    case "InvalidS3KeyException":
+    case "com.amazonaws.polly#InvalidS3KeyException":
+      throw await de_InvalidS3KeyExceptionRes(parsedOutput, context);
+    case "InvalidSampleRateException":
+    case "com.amazonaws.polly#InvalidSampleRateException":
+      throw await de_InvalidSampleRateExceptionRes(parsedOutput, context);
+    case "InvalidSnsTopicArnException":
+    case "com.amazonaws.polly#InvalidSnsTopicArnException":
+      throw await de_InvalidSnsTopicArnExceptionRes(parsedOutput, context);
+    case "InvalidSsmlException":
+    case "com.amazonaws.polly#InvalidSsmlException":
+      throw await de_InvalidSsmlExceptionRes(parsedOutput, context);
+    case "LanguageNotSupportedException":
+    case "com.amazonaws.polly#LanguageNotSupportedException":
+      throw await de_LanguageNotSupportedExceptionRes(parsedOutput, context);
+    case "LexiconNotFoundException":
+    case "com.amazonaws.polly#LexiconNotFoundException":
+      throw await de_LexiconNotFoundExceptionRes(parsedOutput, context);
+    case "MarksNotSupportedForFormatException":
+    case "com.amazonaws.polly#MarksNotSupportedForFormatException":
+      throw await de_MarksNotSupportedForFormatExceptionRes(parsedOutput, context);
+    case "ServiceFailureException":
+    case "com.amazonaws.polly#ServiceFailureException":
+      throw await de_ServiceFailureExceptionRes(parsedOutput, context);
+    case "SsmlMarksNotSupportedForTextTypeException":
+    case "com.amazonaws.polly#SsmlMarksNotSupportedForTextTypeException":
+      throw await de_SsmlMarksNotSupportedForTextTypeExceptionRes(parsedOutput, context);
+    case "TextLengthExceededException":
+    case "com.amazonaws.polly#TextLengthExceededException":
+      throw await de_TextLengthExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartSpeechSynthesisTaskCommandError");
+var de_SynthesizeSpeechCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_SynthesizeSpeechCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_CT]: [, output.headers[_ct]],
+    [_RC]: [() => void 0 !== output.headers[_xar], () => (0, import_smithy_client.strictParseInt32)(output.headers[_xar])]
+  });
+  const data = output.body;
+  context.sdkStreamMixin(data);
+  contents.AudioStream = data;
+  return contents;
+}, "de_SynthesizeSpeechCommand");
+var de_SynthesizeSpeechCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "EngineNotSupportedException":
+    case "com.amazonaws.polly#EngineNotSupportedException":
+      throw await de_EngineNotSupportedExceptionRes(parsedOutput, context);
+    case "InvalidSampleRateException":
+    case "com.amazonaws.polly#InvalidSampleRateException":
+      throw await de_InvalidSampleRateExceptionRes(parsedOutput, context);
+    case "InvalidSsmlException":
+    case "com.amazonaws.polly#InvalidSsmlException":
+      throw await de_InvalidSsmlExceptionRes(parsedOutput, context);
+    case "LanguageNotSupportedException":
+    case "com.amazonaws.polly#LanguageNotSupportedException":
+      throw await de_LanguageNotSupportedExceptionRes(parsedOutput, context);
+    case "LexiconNotFoundException":
+    case "com.amazonaws.polly#LexiconNotFoundException":
+      throw await de_LexiconNotFoundExceptionRes(parsedOutput, context);
+    case "MarksNotSupportedForFormatException":
+    case "com.amazonaws.polly#MarksNotSupportedForFormatException":
+      throw await de_MarksNotSupportedForFormatExceptionRes(parsedOutput, context);
+    case "ServiceFailureException":
+    case "com.amazonaws.polly#ServiceFailureException":
+      throw await de_ServiceFailureExceptionRes(parsedOutput, context);
+    case "SsmlMarksNotSupportedForTextTypeException":
+    case "com.amazonaws.polly#SsmlMarksNotSupportedForTextTypeException":
+      throw await de_SsmlMarksNotSupportedForTextTypeExceptionRes(parsedOutput, context);
+    case "TextLengthExceededException":
+    case "com.amazonaws.polly#TextLengthExceededException":
+      throw await de_TextLengthExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SynthesizeSpeechCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(PollyServiceException);
+var de_EngineNotSupportedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new EngineNotSupportedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_EngineNotSupportedExceptionRes");
+var de_InvalidLexiconExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InvalidLexiconException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InvalidLexiconExceptionRes");
+var de_InvalidNextTokenExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InvalidNextTokenException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InvalidNextTokenExceptionRes");
+var de_InvalidS3BucketExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InvalidS3BucketException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InvalidS3BucketExceptionRes");
+var de_InvalidS3KeyExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InvalidS3KeyException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InvalidS3KeyExceptionRes");
+var de_InvalidSampleRateExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InvalidSampleRateException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InvalidSampleRateExceptionRes");
+var de_InvalidSnsTopicArnExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InvalidSnsTopicArnException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InvalidSnsTopicArnExceptionRes");
+var de_InvalidSsmlExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InvalidSsmlException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InvalidSsmlExceptionRes");
+var de_InvalidTaskIdExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InvalidTaskIdException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InvalidTaskIdExceptionRes");
+var de_LanguageNotSupportedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new LanguageNotSupportedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_LanguageNotSupportedExceptionRes");
+var de_LexiconNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new LexiconNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_LexiconNotFoundExceptionRes");
+var de_LexiconSizeExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new LexiconSizeExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_LexiconSizeExceededExceptionRes");
+var de_MarksNotSupportedForFormatExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new MarksNotSupportedForFormatException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_MarksNotSupportedForFormatExceptionRes");
+var de_MaxLexemeLengthExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new MaxLexemeLengthExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_MaxLexemeLengthExceededExceptionRes");
+var de_MaxLexiconsNumberExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new MaxLexiconsNumberExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_MaxLexiconsNumberExceededExceptionRes");
+var de_ServiceFailureExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceFailureException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceFailureExceptionRes");
+var de_SsmlMarksNotSupportedForTextTypeExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new SsmlMarksNotSupportedForTextTypeException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_SsmlMarksNotSupportedForTextTypeExceptionRes");
+var de_SynthesisTaskNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new SynthesisTaskNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_SynthesisTaskNotFoundExceptionRes");
+var de_TextLengthExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new TextLengthExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_TextLengthExceededExceptionRes");
+var de_UnsupportedPlsAlphabetExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new UnsupportedPlsAlphabetException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_UnsupportedPlsAlphabetExceptionRes");
+var de_UnsupportedPlsLanguageExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new UnsupportedPlsLanguageException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_UnsupportedPlsLanguageExceptionRes");
+var de_LexiconAttributes = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Alphabet: import_smithy_client.expectString,
+    LanguageCode: import_smithy_client.expectString,
+    LastModified: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    LexemesCount: import_smithy_client.expectInt32,
+    LexiconArn: import_smithy_client.expectString,
+    Size: import_smithy_client.expectInt32
+  });
+}, "de_LexiconAttributes");
+var de_LexiconDescription = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Attributes: (_) => de_LexiconAttributes(_, context),
+    Name: import_smithy_client.expectString
+  });
+}, "de_LexiconDescription");
+var de_LexiconDescriptionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LexiconDescription(entry, context);
+  });
+  return retVal;
+}, "de_LexiconDescriptionList");
+var de_SynthesisTask = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Engine: import_smithy_client.expectString,
+    LanguageCode: import_smithy_client.expectString,
+    LexiconNames: import_smithy_client._json,
+    OutputFormat: import_smithy_client.expectString,
+    OutputUri: import_smithy_client.expectString,
+    RequestCharacters: import_smithy_client.expectInt32,
+    SampleRate: import_smithy_client.expectString,
+    SnsTopicArn: import_smithy_client.expectString,
+    SpeechMarkTypes: import_smithy_client._json,
+    TaskId: import_smithy_client.expectString,
+    TaskStatus: import_smithy_client.expectString,
+    TaskStatusReason: import_smithy_client.expectString,
+    TextType: import_smithy_client.expectString,
+    VoiceId: import_smithy_client.expectString
+  });
+}, "de_SynthesisTask");
+var de_SynthesisTasks = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SynthesisTask(entry, context);
+  });
+  return retVal;
+}, "de_SynthesisTasks");
+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 _CT = "ContentType";
+var _E = "Engine";
+var _IALC = "IncludeAdditionalLanguageCodes";
+var _LC = "LanguageCode";
+var _MR = "MaxResults";
+var _NT = "NextToken";
+var _RC = "RequestCharacters";
+var _S = "Status";
+var _ct = "content-type";
+var _xar = "x-amzn-requestcharacters";
+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");
+
+// src/commands/DeleteLexiconCommand.ts
+var _DeleteLexiconCommand = class _DeleteLexiconCommand 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("Parrot_v1", "DeleteLexicon", {}).n("PollyClient", "DeleteLexiconCommand").f(void 0, void 0).ser(se_DeleteLexiconCommand).de(de_DeleteLexiconCommand).build() {
+};
+__name(_DeleteLexiconCommand, "DeleteLexiconCommand");
+var DeleteLexiconCommand = _DeleteLexiconCommand;
+
+// src/commands/DescribeVoicesCommand.ts
+
+
+
+
+var _DescribeVoicesCommand = class _DescribeVoicesCommand 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("Parrot_v1", "DescribeVoices", {}).n("PollyClient", "DescribeVoicesCommand").f(void 0, void 0).ser(se_DescribeVoicesCommand).de(de_DescribeVoicesCommand).build() {
+};
+__name(_DescribeVoicesCommand, "DescribeVoicesCommand");
+var DescribeVoicesCommand = _DescribeVoicesCommand;
+
+// src/commands/GetLexiconCommand.ts
+
+
+
+
+var _GetLexiconCommand = class _GetLexiconCommand 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("Parrot_v1", "GetLexicon", {}).n("PollyClient", "GetLexiconCommand").f(void 0, GetLexiconOutputFilterSensitiveLog).ser(se_GetLexiconCommand).de(de_GetLexiconCommand).build() {
+};
+__name(_GetLexiconCommand, "GetLexiconCommand");
+var GetLexiconCommand = _GetLexiconCommand;
+
+// src/commands/GetSpeechSynthesisTaskCommand.ts
+
+
+
+
+var _GetSpeechSynthesisTaskCommand = class _GetSpeechSynthesisTaskCommand 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("Parrot_v1", "GetSpeechSynthesisTask", {}).n("PollyClient", "GetSpeechSynthesisTaskCommand").f(void 0, void 0).ser(se_GetSpeechSynthesisTaskCommand).de(de_GetSpeechSynthesisTaskCommand).build() {
+};
+__name(_GetSpeechSynthesisTaskCommand, "GetSpeechSynthesisTaskCommand");
+var GetSpeechSynthesisTaskCommand = _GetSpeechSynthesisTaskCommand;
+
+// src/commands/ListLexiconsCommand.ts
+
+
+
+
+var _ListLexiconsCommand = class _ListLexiconsCommand 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("Parrot_v1", "ListLexicons", {}).n("PollyClient", "ListLexiconsCommand").f(void 0, void 0).ser(se_ListLexiconsCommand).de(de_ListLexiconsCommand).build() {
+};
+__name(_ListLexiconsCommand, "ListLexiconsCommand");
+var ListLexiconsCommand = _ListLexiconsCommand;
+
+// src/commands/ListSpeechSynthesisTasksCommand.ts
+
+
+
+
+var _ListSpeechSynthesisTasksCommand = class _ListSpeechSynthesisTasksCommand 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("Parrot_v1", "ListSpeechSynthesisTasks", {}).n("PollyClient", "ListSpeechSynthesisTasksCommand").f(void 0, void 0).ser(se_ListSpeechSynthesisTasksCommand).de(de_ListSpeechSynthesisTasksCommand).build() {
+};
+__name(_ListSpeechSynthesisTasksCommand, "ListSpeechSynthesisTasksCommand");
+var ListSpeechSynthesisTasksCommand = _ListSpeechSynthesisTasksCommand;
+
+// src/commands/PutLexiconCommand.ts
+
+
+
+
+var _PutLexiconCommand = class _PutLexiconCommand 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("Parrot_v1", "PutLexicon", {}).n("PollyClient", "PutLexiconCommand").f(PutLexiconInputFilterSensitiveLog, void 0).ser(se_PutLexiconCommand).de(de_PutLexiconCommand).build() {
+};
+__name(_PutLexiconCommand, "PutLexiconCommand");
+var PutLexiconCommand = _PutLexiconCommand;
+
+// src/commands/StartSpeechSynthesisTaskCommand.ts
+
+
+
+
+var _StartSpeechSynthesisTaskCommand = class _StartSpeechSynthesisTaskCommand 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("Parrot_v1", "StartSpeechSynthesisTask", {}).n("PollyClient", "StartSpeechSynthesisTaskCommand").f(void 0, void 0).ser(se_StartSpeechSynthesisTaskCommand).de(de_StartSpeechSynthesisTaskCommand).build() {
+};
+__name(_StartSpeechSynthesisTaskCommand, "StartSpeechSynthesisTaskCommand");
+var StartSpeechSynthesisTaskCommand = _StartSpeechSynthesisTaskCommand;
+
+// src/commands/SynthesizeSpeechCommand.ts
+
+
+
+
+var _SynthesizeSpeechCommand = class _SynthesizeSpeechCommand 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("Parrot_v1", "SynthesizeSpeech", {}).n("PollyClient", "SynthesizeSpeechCommand").f(void 0, SynthesizeSpeechOutputFilterSensitiveLog).ser(se_SynthesizeSpeechCommand).de(de_SynthesizeSpeechCommand).build() {
+};
+__name(_SynthesizeSpeechCommand, "SynthesizeSpeechCommand");
+var SynthesizeSpeechCommand = _SynthesizeSpeechCommand;
+
+// src/Polly.ts
+var commands = {
+  DeleteLexiconCommand,
+  DescribeVoicesCommand,
+  GetLexiconCommand,
+  GetSpeechSynthesisTaskCommand,
+  ListLexiconsCommand,
+  ListSpeechSynthesisTasksCommand,
+  PutLexiconCommand,
+  StartSpeechSynthesisTaskCommand,
+  SynthesizeSpeechCommand
+};
+var _Polly = class _Polly extends PollyClient {
+};
+__name(_Polly, "Polly");
+var Polly = _Polly;
+(0, import_smithy_client.createAggregatedClient)(commands, Polly);
+
+// src/pagination/ListSpeechSynthesisTasksPaginator.ts
+
+var paginateListSpeechSynthesisTasks = (0, import_core.createPaginator)(PollyClient, ListSpeechSynthesisTasksCommand, "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 = {
+  DeleteLexiconCommand,
+  DescribeVoicesCommand,
+  Engine,
+  EngineNotSupportedException,
+  Gender,
+  GetLexiconCommand,
+  GetLexiconOutputFilterSensitiveLog,
+  GetSpeechSynthesisTaskCommand,
+  InvalidLexiconException,
+  InvalidNextTokenException,
+  InvalidS3BucketException,
+  InvalidS3KeyException,
+  InvalidSampleRateException,
+  InvalidSnsTopicArnException,
+  InvalidSsmlException,
+  InvalidTaskIdException,
+  LanguageCode,
+  LanguageNotSupportedException,
+  LexiconFilterSensitiveLog,
+  LexiconNotFoundException,
+  LexiconSizeExceededException,
+  ListLexiconsCommand,
+  ListSpeechSynthesisTasksCommand,
+  MarksNotSupportedForFormatException,
+  MaxLexemeLengthExceededException,
+  MaxLexiconsNumberExceededException,
+  OutputFormat,
+  Polly,
+  PollyClient,
+  PollyServiceException,
+  PutLexiconCommand,
+  PutLexiconInputFilterSensitiveLog,
+  ServiceFailureException,
+  SpeechMarkType,
+  SsmlMarksNotSupportedForTextTypeException,
+  StartSpeechSynthesisTaskCommand,
+  SynthesisTaskNotFoundException,
+  SynthesizeSpeechCommand,
+  SynthesizeSpeechOutputFilterSensitiveLog,
+  TaskStatus,
+  TextLengthExceededException,
+  TextType,
+  UnsupportedPlsAlphabetException,
+  UnsupportedPlsLanguageException,
+  VoiceId,
+  __Client,
+  paginateListSpeechSynthesisTasks
+});