npm - @aws-sdk/client-polly - Versions diffs - 3.901.0 → 3.907.0 - Mend

@aws-sdk/client-polly 3.901.0 → 3.907.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist-cjs/index.js +1396 -1635
package/package.json +6 -6

package/dist-cjs/index.js CHANGED Viewed

@@ -1,1696 +1,1457 @@
-"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 index_exports = {};
-__export(index_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(index_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");
+'use strict';
-var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
+var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
+var middlewareLogger = require('@aws-sdk/middleware-logger');
+var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
+var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
+var configResolver = require('@smithy/config-resolver');
+var core = require('@smithy/core');
+var middlewareContentLength = require('@smithy/middleware-content-length');
+var middlewareEndpoint = require('@smithy/middleware-endpoint');
+var middlewareRetry = require('@smithy/middleware-retry');
+var smithyClient = require('@smithy/smithy-client');
+var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
+var runtimeConfig = require('./runtimeConfig');
+var regionConfigResolver = require('@aws-sdk/region-config-resolver');
+var protocolHttp = require('@smithy/protocol-http');
+var middlewareSerde = require('@smithy/middleware-serde');
+var core$1 = require('@aws-sdk/core');
-// src/endpoint/EndpointParameters.ts
-var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
-  return Object.assign(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" }
+const resolveClientEndpointParameters = (options) => {
+    return Object.assign(options, {
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "polly",
+    });
+};
+const 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");
+const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
+    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+    let _credentials = runtimeConfig.credentials;
+    return {
+        setHttpAuthScheme(httpAuthScheme) {
+            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+            if (index === -1) {
+                _httpAuthSchemes.push(httpAuthScheme);
+            }
+            else {
+                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+            }
+        },
+        httpAuthSchemes() {
+            return _httpAuthSchemes;
+        },
+        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+            _httpAuthSchemeProvider = httpAuthSchemeProvider;
+        },
+        httpAuthSchemeProvider() {
+            return _httpAuthSchemeProvider;
+        },
+        setCredentials(credentials) {
+            _credentials = credentials;
+        },
+        credentials() {
+            return _credentials;
+        },
+    };
+};
+const resolveHttpAuthRuntimeConfig = (config) => {
+    return {
+        httpAuthSchemes: config.httpAuthSchemes(),
+        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+        credentials: config.credentials(),
+    };
+};
-// 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");
+const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
+    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    extensions.forEach((extension) => extension.configure(extensionConfiguration));
+    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+};
-// 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;
+class PollyClient extends smithyClient.Client {
+    config;
+    constructor(...[configuration]) {
+        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        super(_config_0);
+        this.initConfig = _config_0;
+        const _config_1 = resolveClientEndpointParameters(_config_0);
+        const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
+        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
+        const _config_4 = configResolver.resolveRegionConfig(_config_3);
+        const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
+        const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
+        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
+        this.config = _config_8;
+        this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
+        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
+        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
+        this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultPollyHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+                "aws.auth#sigv4": config.credentials,
+            }),
+        }));
+        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+    }
+    destroy() {
+        super.destroy();
     }
-  };
-}, "getHttpAuthExtensionConfiguration");
-var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
-  return {
-    httpAuthSchemes: config.httpAuthSchemes(),
-    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
-    credentials: config.credentials()
-  };
-}, "resolveHttpAuthRuntimeConfig");
+}
-// src/runtimeExtensions.ts
-var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
-  const extensionConfiguration = Object.assign(
-    (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
-    (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
-    (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
-    getHttpAuthExtensionConfiguration(runtimeConfig)
-  );
-  extensions.forEach((extension) => extension.configure(extensionConfiguration));
-  return Object.assign(
-    runtimeConfig,
-    (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
-    (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
-    (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
-    resolveHttpAuthRuntimeConfig(extensionConfiguration)
-  );
-}, "resolveRuntimeExtensions");
+class PollyServiceException extends smithyClient.ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, PollyServiceException.prototype);
+    }
+}
-// src/PollyClient.ts
-var PollyClient = class extends import_smithy_client.Client {
-  static {
-    __name(this, "PollyClient");
-  }
-  /**
-   * The resolved configuration of PollyClient class. This is resolved and normalized from the {@link PollyClientConfig | constructor configuration interface}.
-   */
-  config;
-  constructor(...[configuration]) {
-    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
-    super(_config_0);
-    this.initConfig = _config_0;
-    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_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
-    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
-    this.config = _config_8;
-    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_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
-        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultPollyHttpAuthSchemeParametersProvider,
-        identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
-          "aws.auth#sigv4": config.credentials
-        }), "identityProviderConfigProvider")
-      })
-    );
-    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();
-  }
+class LexiconNotFoundException extends PollyServiceException {
+    name = "LexiconNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LexiconNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LexiconNotFoundException.prototype);
+    }
+}
+class ServiceFailureException extends PollyServiceException {
+    name = "ServiceFailureException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "ServiceFailureException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceFailureException.prototype);
+    }
+}
+const Engine = {
+    GENERATIVE: "generative",
+    LONG_FORM: "long-form",
+    NEURAL: "neural",
+    STANDARD: "standard",
 };
-// src/Polly.ts
-// src/commands/DeleteLexiconCommand.ts
-var import_middleware_serde = require("@smithy/middleware-serde");
-// src/protocols/Aws_restJson1.ts
-var import_core2 = require("@aws-sdk/core");
-// src/models/models_0.ts
-// src/models/PollyServiceException.ts
-var PollyServiceException = class _PollyServiceException extends import_smithy_client.ServiceException {
-  static {
-    __name(this, "PollyServiceException");
-  }
-  /**
-   * @internal
-   */
-  constructor(options) {
-    super(options);
-    Object.setPrototypeOf(this, _PollyServiceException.prototype);
-  }
+const LanguageCode = {
+    ar_AE: "ar-AE",
+    arb: "arb",
+    ca_ES: "ca-ES",
+    cmn_CN: "cmn-CN",
+    cs_CZ: "cs-CZ",
+    cy_GB: "cy-GB",
+    da_DK: "da-DK",
+    de_AT: "de-AT",
+    de_CH: "de-CH",
+    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_SG: "en-SG",
+    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",
+};
+const Gender = {
+    Female: "Female",
+    Male: "Male",
+};
+const VoiceId = {
+    Aditi: "Aditi",
+    Adriano: "Adriano",
+    Amy: "Amy",
+    Andres: "Andres",
+    Aria: "Aria",
+    Arlet: "Arlet",
+    Arthur: "Arthur",
+    Astrid: "Astrid",
+    Ayanda: "Ayanda",
+    Bianca: "Bianca",
+    Brian: "Brian",
+    Burcu: "Burcu",
+    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",
+    Jasmine: "Jasmine",
+    Jihye: "Jihye",
+    Jitka: "Jitka",
+    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",
+    Sabrina: "Sabrina",
+    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",
+};
+class InvalidNextTokenException extends PollyServiceException {
+    name = "InvalidNextTokenException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidNextTokenException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidNextTokenException.prototype);
+    }
+}
+class EngineNotSupportedException extends PollyServiceException {
+    name = "EngineNotSupportedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "EngineNotSupportedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, EngineNotSupportedException.prototype);
+    }
+}
+const OutputFormat = {
+    JSON: "json",
+    MP3: "mp3",
+    OGG_OPUS: "ogg_opus",
+    OGG_VORBIS: "ogg_vorbis",
+    PCM: "pcm",
+};
+const SpeechMarkType = {
+    SENTENCE: "sentence",
+    SSML: "ssml",
+    VISEME: "viseme",
+    WORD: "word",
+};
+const TaskStatus = {
+    COMPLETED: "completed",
+    FAILED: "failed",
+    IN_PROGRESS: "inProgress",
+    SCHEDULED: "scheduled",
 };
+const TextType = {
+    SSML: "ssml",
+    TEXT: "text",
+};
+class InvalidTaskIdException extends PollyServiceException {
+    name = "InvalidTaskIdException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTaskIdException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTaskIdException.prototype);
+    }
+}
+class SynthesisTaskNotFoundException extends PollyServiceException {
+    name = "SynthesisTaskNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SynthesisTaskNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SynthesisTaskNotFoundException.prototype);
+    }
+}
+class InvalidLexiconException extends PollyServiceException {
+    name = "InvalidLexiconException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidLexiconException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidLexiconException.prototype);
+    }
+}
+class InvalidS3BucketException extends PollyServiceException {
+    name = "InvalidS3BucketException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidS3BucketException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidS3BucketException.prototype);
+    }
+}
+class InvalidS3KeyException extends PollyServiceException {
+    name = "InvalidS3KeyException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidS3KeyException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidS3KeyException.prototype);
+    }
+}
+class InvalidSampleRateException extends PollyServiceException {
+    name = "InvalidSampleRateException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidSampleRateException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidSampleRateException.prototype);
+    }
+}
+class InvalidSnsTopicArnException extends PollyServiceException {
+    name = "InvalidSnsTopicArnException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidSnsTopicArnException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidSnsTopicArnException.prototype);
+    }
+}
+class InvalidSsmlException extends PollyServiceException {
+    name = "InvalidSsmlException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidSsmlException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidSsmlException.prototype);
+    }
+}
+class LanguageNotSupportedException extends PollyServiceException {
+    name = "LanguageNotSupportedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LanguageNotSupportedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LanguageNotSupportedException.prototype);
+    }
+}
+class LexiconSizeExceededException extends PollyServiceException {
+    name = "LexiconSizeExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LexiconSizeExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LexiconSizeExceededException.prototype);
+    }
+}
+class MarksNotSupportedForFormatException extends PollyServiceException {
+    name = "MarksNotSupportedForFormatException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MarksNotSupportedForFormatException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MarksNotSupportedForFormatException.prototype);
+    }
+}
+class MaxLexemeLengthExceededException extends PollyServiceException {
+    name = "MaxLexemeLengthExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MaxLexemeLengthExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MaxLexemeLengthExceededException.prototype);
+    }
+}
+class MaxLexiconsNumberExceededException extends PollyServiceException {
+    name = "MaxLexiconsNumberExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MaxLexiconsNumberExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MaxLexiconsNumberExceededException.prototype);
+    }
+}
+class UnsupportedPlsAlphabetException extends PollyServiceException {
+    name = "UnsupportedPlsAlphabetException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UnsupportedPlsAlphabetException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UnsupportedPlsAlphabetException.prototype);
+    }
+}
+class UnsupportedPlsLanguageException extends PollyServiceException {
+    name = "UnsupportedPlsLanguageException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UnsupportedPlsLanguageException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UnsupportedPlsLanguageException.prototype);
+    }
+}
+class SsmlMarksNotSupportedForTextTypeException extends PollyServiceException {
+    name = "SsmlMarksNotSupportedForTextTypeException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SsmlMarksNotSupportedForTextTypeException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SsmlMarksNotSupportedForTextTypeException.prototype);
+    }
+}
+class TextLengthExceededException extends PollyServiceException {
+    name = "TextLengthExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TextLengthExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TextLengthExceededException.prototype);
+    }
+}
+const LexiconFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Content && { Content: smithyClient.SENSITIVE_STRING }),
+});
+const GetLexiconOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Lexicon && { Lexicon: LexiconFilterSensitiveLog(obj.Lexicon) }),
+});
+const PutLexiconInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Content && { Content: smithyClient.SENSITIVE_STRING }),
+});
+const SynthesizeSpeechOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
-// src/models/models_0.ts
-var LexiconNotFoundException = class _LexiconNotFoundException extends PollyServiceException {
-  static {
-    __name(this, "LexiconNotFoundException");
-  }
-  name = "LexiconNotFoundException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "LexiconNotFoundException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _LexiconNotFoundException.prototype);
-  }
+const se_DeleteLexiconCommand = async (input, context) => {
+    const b = 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();
 };
-var ServiceFailureException = class _ServiceFailureException extends PollyServiceException {
-  static {
-    __name(this, "ServiceFailureException");
-  }
-  name = "ServiceFailureException";
-  $fault = "server";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ServiceFailureException",
-      $fault: "server",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _ServiceFailureException.prototype);
-  }
+const se_DescribeVoicesCommand = async (input, context) => {
+    const b = core.requestBuilder(input, context);
+    const headers = {};
+    b.bp("/v1/voices");
+    const query = smithyClient.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();
 };
-var Engine = {
-  GENERATIVE: "generative",
-  LONG_FORM: "long-form",
-  NEURAL: "neural",
-  STANDARD: "standard"
+const se_GetLexiconCommand = async (input, context) => {
+    const b = 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();
 };
-var LanguageCode = {
-  ar_AE: "ar-AE",
-  arb: "arb",
-  ca_ES: "ca-ES",
-  cmn_CN: "cmn-CN",
-  cs_CZ: "cs-CZ",
-  cy_GB: "cy-GB",
-  da_DK: "da-DK",
-  de_AT: "de-AT",
-  de_CH: "de-CH",
-  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_SG: "en-SG",
-  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"
+const se_GetSpeechSynthesisTaskCommand = async (input, context) => {
+    const b = 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();
 };
-var Gender = {
-  Female: "Female",
-  Male: "Male"
+const se_ListLexiconsCommand = async (input, context) => {
+    const b = core.requestBuilder(input, context);
+    const headers = {};
+    b.bp("/v1/lexicons");
+    const query = smithyClient.map({
+        [_NT]: [, input[_NT]],
+    });
+    let body;
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
 };
-var VoiceId = {
-  Aditi: "Aditi",
-  Adriano: "Adriano",
-  Amy: "Amy",
-  Andres: "Andres",
-  Aria: "Aria",
-  Arlet: "Arlet",
-  Arthur: "Arthur",
-  Astrid: "Astrid",
-  Ayanda: "Ayanda",
-  Bianca: "Bianca",
-  Brian: "Brian",
-  Burcu: "Burcu",
-  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",
-  Jasmine: "Jasmine",
-  Jihye: "Jihye",
-  Jitka: "Jitka",
-  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",
-  Sabrina: "Sabrina",
-  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"
+const se_ListSpeechSynthesisTasksCommand = async (input, context) => {
+    const b = core.requestBuilder(input, context);
+    const headers = {};
+    b.bp("/v1/synthesisTasks");
+    const query = smithyClient.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();
 };
-var InvalidNextTokenException = class _InvalidNextTokenException extends PollyServiceException {
-  static {
-    __name(this, "InvalidNextTokenException");
-  }
-  name = "InvalidNextTokenException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidNextTokenException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _InvalidNextTokenException.prototype);
-  }
+const se_PutLexiconCommand = async (input, context) => {
+    const b = 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(smithyClient.take(input, {
+        Content: [],
+    }));
+    b.m("PUT").h(headers).b(body);
+    return b.build();
 };
-var EngineNotSupportedException = class _EngineNotSupportedException extends PollyServiceException {
-  static {
-    __name(this, "EngineNotSupportedException");
-  }
-  name = "EngineNotSupportedException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "EngineNotSupportedException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _EngineNotSupportedException.prototype);
-  }
+const se_StartSpeechSynthesisTaskCommand = async (input, context) => {
+    const b = core.requestBuilder(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/v1/synthesisTasks");
+    let body;
+    body = JSON.stringify(smithyClient.take(input, {
+        Engine: [],
+        LanguageCode: [],
+        LexiconNames: (_) => smithyClient._json(_),
+        OutputFormat: [],
+        OutputS3BucketName: [],
+        OutputS3KeyPrefix: [],
+        SampleRate: [],
+        SnsTopicArn: [],
+        SpeechMarkTypes: (_) => smithyClient._json(_),
+        Text: [],
+        TextType: [],
+        VoiceId: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
-var OutputFormat = {
-  JSON: "json",
-  MP3: "mp3",
-  OGG_OPUS: "ogg_opus",
-  OGG_VORBIS: "ogg_vorbis",
-  PCM: "pcm"
+const se_SynthesizeSpeechCommand = async (input, context) => {
+    const b = core.requestBuilder(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/v1/speech");
+    let body;
+    body = JSON.stringify(smithyClient.take(input, {
+        Engine: [],
+        LanguageCode: [],
+        LexiconNames: (_) => smithyClient._json(_),
+        OutputFormat: [],
+        SampleRate: [],
+        SpeechMarkTypes: (_) => smithyClient._json(_),
+        Text: [],
+        TextType: [],
+        VoiceId: [],
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
 };
-var SpeechMarkType = {
-  SENTENCE: "sentence",
-  SSML: "ssml",
-  VISEME: "viseme",
-  WORD: "word"
+const de_DeleteLexiconCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = smithyClient.map({
+        $metadata: deserializeMetadata(output),
+    });
+    await smithyClient.collectBody(output.body, context);
+    return contents;
 };
-var TaskStatus = {
-  COMPLETED: "completed",
-  FAILED: "failed",
-  IN_PROGRESS: "inProgress",
-  SCHEDULED: "scheduled"
+const de_DescribeVoicesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = smithyClient.map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+    const doc = smithyClient.take(data, {
+        NextToken: smithyClient.expectString,
+        Voices: smithyClient._json,
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
-var TextType = {
-  SSML: "ssml",
-  TEXT: "text"
+const de_GetLexiconCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = smithyClient.map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+    const doc = smithyClient.take(data, {
+        Lexicon: smithyClient._json,
+        LexiconAttributes: (_) => de_LexiconAttributes(_),
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
-var InvalidTaskIdException = class _InvalidTaskIdException extends PollyServiceException {
-  static {
-    __name(this, "InvalidTaskIdException");
-  }
-  name = "InvalidTaskIdException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidTaskIdException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _InvalidTaskIdException.prototype);
-  }
+const de_GetSpeechSynthesisTaskCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = smithyClient.map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+    const doc = smithyClient.take(data, {
+        SynthesisTask: (_) => de_SynthesisTask(_),
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
-var SynthesisTaskNotFoundException = class _SynthesisTaskNotFoundException extends PollyServiceException {
-  static {
-    __name(this, "SynthesisTaskNotFoundException");
-  }
-  name = "SynthesisTaskNotFoundException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "SynthesisTaskNotFoundException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _SynthesisTaskNotFoundException.prototype);
-  }
+const de_ListLexiconsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = smithyClient.map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+    const doc = smithyClient.take(data, {
+        Lexicons: (_) => de_LexiconDescriptionList(_),
+        NextToken: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
-var InvalidLexiconException = class _InvalidLexiconException extends PollyServiceException {
-  static {
-    __name(this, "InvalidLexiconException");
-  }
-  name = "InvalidLexiconException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidLexiconException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _InvalidLexiconException.prototype);
-  }
+const de_ListSpeechSynthesisTasksCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = smithyClient.map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+    const doc = smithyClient.take(data, {
+        NextToken: smithyClient.expectString,
+        SynthesisTasks: (_) => de_SynthesisTasks(_),
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
-var InvalidS3BucketException = class _InvalidS3BucketException extends PollyServiceException {
-  static {
-    __name(this, "InvalidS3BucketException");
-  }
-  name = "InvalidS3BucketException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidS3BucketException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _InvalidS3BucketException.prototype);
-  }
+const de_PutLexiconCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = smithyClient.map({
+        $metadata: deserializeMetadata(output),
+    });
+    await smithyClient.collectBody(output.body, context);
+    return contents;
 };
-var InvalidS3KeyException = class _InvalidS3KeyException extends PollyServiceException {
-  static {
-    __name(this, "InvalidS3KeyException");
-  }
-  name = "InvalidS3KeyException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidS3KeyException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _InvalidS3KeyException.prototype);
-  }
+const de_StartSpeechSynthesisTaskCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = smithyClient.map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
+    const doc = smithyClient.take(data, {
+        SynthesisTask: (_) => de_SynthesisTask(_),
+    });
+    Object.assign(contents, doc);
+    return contents;
 };
-var InvalidSampleRateException = class _InvalidSampleRateException extends PollyServiceException {
-  static {
-    __name(this, "InvalidSampleRateException");
-  }
-  name = "InvalidSampleRateException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidSampleRateException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _InvalidSampleRateException.prototype);
-  }
+const de_SynthesizeSpeechCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = smithyClient.map({
+        $metadata: deserializeMetadata(output),
+        [_CT]: [, output.headers[_ct]],
+        [_RC]: [() => void 0 !== output.headers[_xar], () => smithyClient.strictParseInt32(output.headers[_xar])],
+    });
+    const data = output.body;
+    context.sdkStreamMixin(data);
+    contents.AudioStream = data;
+    return contents;
 };
-var InvalidSnsTopicArnException = class _InvalidSnsTopicArnException extends PollyServiceException {
-  static {
-    __name(this, "InvalidSnsTopicArnException");
-  }
-  name = "InvalidSnsTopicArnException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidSnsTopicArnException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _InvalidSnsTopicArnException.prototype);
-  }
+const de_CommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await core$1.parseJsonErrorBody(output.body, context),
+    };
+    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "LexiconNotFoundException":
+        case "com.amazonaws.polly#LexiconNotFoundException":
+            throw await de_LexiconNotFoundExceptionRes(parsedOutput);
+        case "ServiceFailureException":
+        case "com.amazonaws.polly#ServiceFailureException":
+            throw await de_ServiceFailureExceptionRes(parsedOutput);
+        case "InvalidNextTokenException":
+        case "com.amazonaws.polly#InvalidNextTokenException":
+            throw await de_InvalidNextTokenExceptionRes(parsedOutput);
+        case "InvalidTaskIdException":
+        case "com.amazonaws.polly#InvalidTaskIdException":
+            throw await de_InvalidTaskIdExceptionRes(parsedOutput);
+        case "SynthesisTaskNotFoundException":
+        case "com.amazonaws.polly#SynthesisTaskNotFoundException":
+            throw await de_SynthesisTaskNotFoundExceptionRes(parsedOutput);
+        case "InvalidLexiconException":
+        case "com.amazonaws.polly#InvalidLexiconException":
+            throw await de_InvalidLexiconExceptionRes(parsedOutput);
+        case "LexiconSizeExceededException":
+        case "com.amazonaws.polly#LexiconSizeExceededException":
+            throw await de_LexiconSizeExceededExceptionRes(parsedOutput);
+        case "MaxLexemeLengthExceededException":
+        case "com.amazonaws.polly#MaxLexemeLengthExceededException":
+            throw await de_MaxLexemeLengthExceededExceptionRes(parsedOutput);
+        case "MaxLexiconsNumberExceededException":
+        case "com.amazonaws.polly#MaxLexiconsNumberExceededException":
+            throw await de_MaxLexiconsNumberExceededExceptionRes(parsedOutput);
+        case "UnsupportedPlsAlphabetException":
+        case "com.amazonaws.polly#UnsupportedPlsAlphabetException":
+            throw await de_UnsupportedPlsAlphabetExceptionRes(parsedOutput);
+        case "UnsupportedPlsLanguageException":
+        case "com.amazonaws.polly#UnsupportedPlsLanguageException":
+            throw await de_UnsupportedPlsLanguageExceptionRes(parsedOutput);
+        case "EngineNotSupportedException":
+        case "com.amazonaws.polly#EngineNotSupportedException":
+            throw await de_EngineNotSupportedExceptionRes(parsedOutput);
+        case "InvalidS3BucketException":
+        case "com.amazonaws.polly#InvalidS3BucketException":
+            throw await de_InvalidS3BucketExceptionRes(parsedOutput);
+        case "InvalidS3KeyException":
+        case "com.amazonaws.polly#InvalidS3KeyException":
+            throw await de_InvalidS3KeyExceptionRes(parsedOutput);
+        case "InvalidSampleRateException":
+        case "com.amazonaws.polly#InvalidSampleRateException":
+            throw await de_InvalidSampleRateExceptionRes(parsedOutput);
+        case "InvalidSnsTopicArnException":
+        case "com.amazonaws.polly#InvalidSnsTopicArnException":
+            throw await de_InvalidSnsTopicArnExceptionRes(parsedOutput);
+        case "InvalidSsmlException":
+        case "com.amazonaws.polly#InvalidSsmlException":
+            throw await de_InvalidSsmlExceptionRes(parsedOutput);
+        case "LanguageNotSupportedException":
+        case "com.amazonaws.polly#LanguageNotSupportedException":
+            throw await de_LanguageNotSupportedExceptionRes(parsedOutput);
+        case "MarksNotSupportedForFormatException":
+        case "com.amazonaws.polly#MarksNotSupportedForFormatException":
+            throw await de_MarksNotSupportedForFormatExceptionRes(parsedOutput);
+        case "SsmlMarksNotSupportedForTextTypeException":
+        case "com.amazonaws.polly#SsmlMarksNotSupportedForTextTypeException":
+            throw await de_SsmlMarksNotSupportedForTextTypeExceptionRes(parsedOutput);
+        case "TextLengthExceededException":
+        case "com.amazonaws.polly#TextLengthExceededException":
+            throw await de_TextLengthExceededExceptionRes(parsedOutput);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
 };
-var InvalidSsmlException = class _InvalidSsmlException extends PollyServiceException {
-  static {
-    __name(this, "InvalidSsmlException");
-  }
-  name = "InvalidSsmlException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidSsmlException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _InvalidSsmlException.prototype);
-  }
+const throwDefaultError = smithyClient.withBaseException(PollyServiceException);
+const de_EngineNotSupportedExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new EngineNotSupportedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-var LanguageNotSupportedException = class _LanguageNotSupportedException extends PollyServiceException {
-  static {
-    __name(this, "LanguageNotSupportedException");
-  }
-  name = "LanguageNotSupportedException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "LanguageNotSupportedException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _LanguageNotSupportedException.prototype);
-  }
+const de_InvalidLexiconExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InvalidLexiconException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-var LexiconSizeExceededException = class _LexiconSizeExceededException extends PollyServiceException {
-  static {
-    __name(this, "LexiconSizeExceededException");
-  }
-  name = "LexiconSizeExceededException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "LexiconSizeExceededException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _LexiconSizeExceededException.prototype);
-  }
+const de_InvalidNextTokenExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InvalidNextTokenException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-var MarksNotSupportedForFormatException = class _MarksNotSupportedForFormatException extends PollyServiceException {
-  static {
-    __name(this, "MarksNotSupportedForFormatException");
-  }
-  name = "MarksNotSupportedForFormatException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "MarksNotSupportedForFormatException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _MarksNotSupportedForFormatException.prototype);
-  }
+const de_InvalidS3BucketExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InvalidS3BucketException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-var MaxLexemeLengthExceededException = class _MaxLexemeLengthExceededException extends PollyServiceException {
-  static {
-    __name(this, "MaxLexemeLengthExceededException");
-  }
-  name = "MaxLexemeLengthExceededException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "MaxLexemeLengthExceededException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _MaxLexemeLengthExceededException.prototype);
-  }
+const de_InvalidS3KeyExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InvalidS3KeyException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-var MaxLexiconsNumberExceededException = class _MaxLexiconsNumberExceededException extends PollyServiceException {
-  static {
-    __name(this, "MaxLexiconsNumberExceededException");
-  }
-  name = "MaxLexiconsNumberExceededException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "MaxLexiconsNumberExceededException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _MaxLexiconsNumberExceededException.prototype);
-  }
+const de_InvalidSampleRateExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InvalidSampleRateException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-var UnsupportedPlsAlphabetException = class _UnsupportedPlsAlphabetException extends PollyServiceException {
-  static {
-    __name(this, "UnsupportedPlsAlphabetException");
-  }
-  name = "UnsupportedPlsAlphabetException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "UnsupportedPlsAlphabetException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _UnsupportedPlsAlphabetException.prototype);
-  }
+const de_InvalidSnsTopicArnExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InvalidSnsTopicArnException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-var UnsupportedPlsLanguageException = class _UnsupportedPlsLanguageException extends PollyServiceException {
-  static {
-    __name(this, "UnsupportedPlsLanguageException");
-  }
-  name = "UnsupportedPlsLanguageException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "UnsupportedPlsLanguageException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _UnsupportedPlsLanguageException.prototype);
-  }
+const de_InvalidSsmlExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InvalidSsmlException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-var SsmlMarksNotSupportedForTextTypeException = class _SsmlMarksNotSupportedForTextTypeException extends PollyServiceException {
-  static {
-    __name(this, "SsmlMarksNotSupportedForTextTypeException");
-  }
-  name = "SsmlMarksNotSupportedForTextTypeException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "SsmlMarksNotSupportedForTextTypeException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _SsmlMarksNotSupportedForTextTypeException.prototype);
-  }
+const de_InvalidTaskIdExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InvalidTaskIdException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-var TextLengthExceededException = class _TextLengthExceededException extends PollyServiceException {
-  static {
-    __name(this, "TextLengthExceededException");
-  }
-  name = "TextLengthExceededException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "TextLengthExceededException",
-      $fault: "client",
-      ...opts
-    });
-    Object.setPrototypeOf(this, _TextLengthExceededException.prototype);
-  }
+const de_LanguageNotSupportedExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new LanguageNotSupportedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-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: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "LexiconNames"),
-      OutputFormat: [],
-      OutputS3BucketName: [],
-      OutputS3KeyPrefix: [],
-      SampleRate: [],
-      SnsTopicArn: [],
-      SpeechMarkTypes: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "SpeechMarkTypes"),
-      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: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "LexiconNames"),
-      OutputFormat: [],
-      SampleRate: [],
-      SpeechMarkTypes: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "SpeechMarkTypes"),
-      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_CommandError(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_DescribeVoicesCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode !== 200 && output.statusCode >= 300) {
-    return de_CommandError(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 (0, import_core2.parseJsonBody)(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_GetLexiconCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode !== 200 && output.statusCode >= 300) {
-    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
-  const doc = (0, import_smithy_client.take)(data, {
-    Lexicon: import_smithy_client._json,
-    LexiconAttributes: /* @__PURE__ */ __name((_) => de_LexiconAttributes(_, context), "LexiconAttributes")
-  });
-  Object.assign(contents, doc);
-  return contents;
-}, "de_GetLexiconCommand");
-var de_GetSpeechSynthesisTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode !== 200 && output.statusCode >= 300) {
-    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
-  const doc = (0, import_smithy_client.take)(data, {
-    SynthesisTask: /* @__PURE__ */ __name((_) => de_SynthesisTask(_, context), "SynthesisTask")
-  });
-  Object.assign(contents, doc);
-  return contents;
-}, "de_GetSpeechSynthesisTaskCommand");
-var de_ListLexiconsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode !== 200 && output.statusCode >= 300) {
-    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
-  const doc = (0, import_smithy_client.take)(data, {
-    Lexicons: /* @__PURE__ */ __name((_) => de_LexiconDescriptionList(_, context), "Lexicons"),
-    NextToken: import_smithy_client.expectString
-  });
-  Object.assign(contents, doc);
-  return contents;
-}, "de_ListLexiconsCommand");
-var de_ListSpeechSynthesisTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode !== 200 && output.statusCode >= 300) {
-    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
-  const doc = (0, import_smithy_client.take)(data, {
-    NextToken: import_smithy_client.expectString,
-    SynthesisTasks: /* @__PURE__ */ __name((_) => de_SynthesisTasks(_, context), "SynthesisTasks")
-  });
-  Object.assign(contents, doc);
-  return contents;
-}, "de_ListSpeechSynthesisTasksCommand");
-var de_PutLexiconCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode !== 200 && output.statusCode >= 300) {
-    return de_CommandError(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_StartSpeechSynthesisTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode !== 200 && output.statusCode >= 300) {
-    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
-  const doc = (0, import_smithy_client.take)(data, {
-    SynthesisTask: /* @__PURE__ */ __name((_) => de_SynthesisTask(_, context), "SynthesisTask")
-  });
-  Object.assign(contents, doc);
-  return contents;
-}, "de_StartSpeechSynthesisTaskCommand");
-var de_SynthesizeSpeechCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode !== 200 && output.statusCode >= 300) {
-    return de_CommandError(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_CommandError = /* @__PURE__ */ __name(async (output, context) => {
-  const parsedOutput = {
-    ...output,
-    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
-  };
-  const errorCode = (0, import_core2.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);
-    case "InvalidNextTokenException":
-    case "com.amazonaws.polly#InvalidNextTokenException":
-      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-    case "InvalidTaskIdException":
-    case "com.amazonaws.polly#InvalidTaskIdException":
-      throw await de_InvalidTaskIdExceptionRes(parsedOutput, context);
-    case "SynthesisTaskNotFoundException":
-    case "com.amazonaws.polly#SynthesisTaskNotFoundException":
-      throw await de_SynthesisTaskNotFoundExceptionRes(parsedOutput, context);
-    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 "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);
-    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 "MarksNotSupportedForFormatException":
-    case "com.amazonaws.polly#MarksNotSupportedForFormatException":
-      throw await de_MarksNotSupportedForFormatExceptionRes(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_CommandError");
-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: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "LastModified"),
-    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: /* @__PURE__ */ __name((_) => de_LexiconAttributes(_, context), "Attributes"),
-    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: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "CreationTime"),
-    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 _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";
-// src/commands/DeleteLexiconCommand.ts
-var DeleteLexiconCommand = class 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() {
-  static {
-    __name(this, "DeleteLexiconCommand");
-  }
+const de_LexiconNotFoundExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new LexiconNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-// src/commands/DescribeVoicesCommand.ts
-var DescribeVoicesCommand = class 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() {
-  static {
-    __name(this, "DescribeVoicesCommand");
-  }
+const de_LexiconSizeExceededExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new LexiconSizeExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-// src/commands/GetLexiconCommand.ts
-var GetLexiconCommand = class 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() {
-  static {
-    __name(this, "GetLexiconCommand");
-  }
+const de_MarksNotSupportedForFormatExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new MarksNotSupportedForFormatException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-// src/commands/GetSpeechSynthesisTaskCommand.ts
-var GetSpeechSynthesisTaskCommand = class 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() {
-  static {
-    __name(this, "GetSpeechSynthesisTaskCommand");
-  }
+const de_MaxLexemeLengthExceededExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new MaxLexemeLengthExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-// src/commands/ListLexiconsCommand.ts
-var ListLexiconsCommand = class 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() {
-  static {
-    __name(this, "ListLexiconsCommand");
-  }
+const de_MaxLexiconsNumberExceededExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new MaxLexiconsNumberExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-// src/commands/ListSpeechSynthesisTasksCommand.ts
-var ListSpeechSynthesisTasksCommand = class 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() {
-  static {
-    __name(this, "ListSpeechSynthesisTasksCommand");
-  }
+const de_ServiceFailureExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ServiceFailureException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
-// src/commands/PutLexiconCommand.ts
-var PutLexiconCommand = class 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() {
-  static {
-    __name(this, "PutLexiconCommand");
-  }
+const de_SsmlMarksNotSupportedForTextTypeExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new SsmlMarksNotSupportedForTextTypeException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
+};
+const de_SynthesisTaskNotFoundExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new SynthesisTaskNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
+};
+const de_TextLengthExceededExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new TextLengthExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
+};
+const de_UnsupportedPlsAlphabetExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new UnsupportedPlsAlphabetException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
 };
+const de_UnsupportedPlsLanguageExceptionRes = async (parsedOutput, context) => {
+    const contents = smithyClient.map({});
+    const data = parsedOutput.body;
+    const doc = smithyClient.take(data, {
+        message: smithyClient.expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new UnsupportedPlsLanguageException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return smithyClient.decorateServiceException(exception, parsedOutput.body);
+};
+const de_LexiconAttributes = (output, context) => {
+    return smithyClient.take(output, {
+        Alphabet: smithyClient.expectString,
+        LanguageCode: smithyClient.expectString,
+        LastModified: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        LexemesCount: smithyClient.expectInt32,
+        LexiconArn: smithyClient.expectString,
+        Size: smithyClient.expectInt32,
+    });
+};
+const de_LexiconDescription = (output, context) => {
+    return smithyClient.take(output, {
+        Attributes: (_) => de_LexiconAttributes(_),
+        Name: smithyClient.expectString,
+    });
+};
+const de_LexiconDescriptionList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_LexiconDescription(entry);
+    });
+    return retVal;
+};
+const de_SynthesisTask = (output, context) => {
+    return smithyClient.take(output, {
+        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        Engine: smithyClient.expectString,
+        LanguageCode: smithyClient.expectString,
+        LexiconNames: smithyClient._json,
+        OutputFormat: smithyClient.expectString,
+        OutputUri: smithyClient.expectString,
+        RequestCharacters: smithyClient.expectInt32,
+        SampleRate: smithyClient.expectString,
+        SnsTopicArn: smithyClient.expectString,
+        SpeechMarkTypes: smithyClient._json,
+        TaskId: smithyClient.expectString,
+        TaskStatus: smithyClient.expectString,
+        TaskStatusReason: smithyClient.expectString,
+        TextType: smithyClient.expectString,
+        VoiceId: smithyClient.expectString,
+    });
+};
+const de_SynthesisTasks = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_SynthesisTask(entry);
+    });
+    return retVal;
+};
+const deserializeMetadata = (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"],
+});
+const _CT = "ContentType";
+const _E = "Engine";
+const _IALC = "IncludeAdditionalLanguageCodes";
+const _LC = "LanguageCode";
+const _MR = "MaxResults";
+const _NT = "NextToken";
+const _RC = "RequestCharacters";
+const _S = "Status";
+const _ct = "content-type";
+const _xar = "x-amzn-requestcharacters";
-// src/commands/StartSpeechSynthesisTaskCommand.ts
+class DeleteLexiconCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Parrot_v1", "DeleteLexicon", {})
+    .n("PollyClient", "DeleteLexiconCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteLexiconCommand)
+    .de(de_DeleteLexiconCommand)
+    .build() {
+}
+class DescribeVoicesCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Parrot_v1", "DescribeVoices", {})
+    .n("PollyClient", "DescribeVoicesCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeVoicesCommand)
+    .de(de_DescribeVoicesCommand)
+    .build() {
+}
+class GetLexiconCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Parrot_v1", "GetLexicon", {})
+    .n("PollyClient", "GetLexiconCommand")
+    .f(void 0, GetLexiconOutputFilterSensitiveLog)
+    .ser(se_GetLexiconCommand)
+    .de(de_GetLexiconCommand)
+    .build() {
+}
-var StartSpeechSynthesisTaskCommand = class 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() {
-  static {
-    __name(this, "StartSpeechSynthesisTaskCommand");
-  }
-};
+class GetSpeechSynthesisTaskCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Parrot_v1", "GetSpeechSynthesisTask", {})
+    .n("PollyClient", "GetSpeechSynthesisTaskCommand")
+    .f(void 0, void 0)
+    .ser(se_GetSpeechSynthesisTaskCommand)
+    .de(de_GetSpeechSynthesisTaskCommand)
+    .build() {
+}
-// src/commands/SynthesizeSpeechCommand.ts
+class ListLexiconsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Parrot_v1", "ListLexicons", {})
+    .n("PollyClient", "ListLexiconsCommand")
+    .f(void 0, void 0)
+    .ser(se_ListLexiconsCommand)
+    .de(de_ListLexiconsCommand)
+    .build() {
+}
+class ListSpeechSynthesisTasksCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Parrot_v1", "ListSpeechSynthesisTasks", {})
+    .n("PollyClient", "ListSpeechSynthesisTasksCommand")
+    .f(void 0, void 0)
+    .ser(se_ListSpeechSynthesisTasksCommand)
+    .de(de_ListSpeechSynthesisTasksCommand)
+    .build() {
+}
+class PutLexiconCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Parrot_v1", "PutLexicon", {})
+    .n("PollyClient", "PutLexiconCommand")
+    .f(PutLexiconInputFilterSensitiveLog, void 0)
+    .ser(se_PutLexiconCommand)
+    .de(de_PutLexiconCommand)
+    .build() {
+}
-var SynthesizeSpeechCommand = class 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() {
-  static {
-    __name(this, "SynthesizeSpeechCommand");
-  }
-};
+class StartSpeechSynthesisTaskCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Parrot_v1", "StartSpeechSynthesisTask", {})
+    .n("PollyClient", "StartSpeechSynthesisTaskCommand")
+    .f(void 0, void 0)
+    .ser(se_StartSpeechSynthesisTaskCommand)
+    .de(de_StartSpeechSynthesisTaskCommand)
+    .build() {
+}
-// src/Polly.ts
-var commands = {
-  DeleteLexiconCommand,
-  DescribeVoicesCommand,
-  GetLexiconCommand,
-  GetSpeechSynthesisTaskCommand,
-  ListLexiconsCommand,
-  ListSpeechSynthesisTasksCommand,
-  PutLexiconCommand,
-  StartSpeechSynthesisTaskCommand,
-  SynthesizeSpeechCommand
-};
-var Polly = class extends PollyClient {
-  static {
-    __name(this, "Polly");
-  }
-};
-(0, import_smithy_client.createAggregatedClient)(commands, Polly);
+class SynthesizeSpeechCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Parrot_v1", "SynthesizeSpeech", {})
+    .n("PollyClient", "SynthesizeSpeechCommand")
+    .f(void 0, SynthesizeSpeechOutputFilterSensitiveLog)
+    .ser(se_SynthesizeSpeechCommand)
+    .de(de_SynthesizeSpeechCommand)
+    .build() {
+}
-// src/pagination/ListSpeechSynthesisTasksPaginator.ts
+const commands = {
+    DeleteLexiconCommand,
+    DescribeVoicesCommand,
+    GetLexiconCommand,
+    GetSpeechSynthesisTaskCommand,
+    ListLexiconsCommand,
+    ListSpeechSynthesisTasksCommand,
+    PutLexiconCommand,
+    StartSpeechSynthesisTaskCommand,
+    SynthesizeSpeechCommand,
+};
+class Polly extends PollyClient {
+}
+smithyClient.createAggregatedClient(commands, Polly);
-var paginateListSpeechSynthesisTasks = (0, import_core.createPaginator)(PollyClient, ListSpeechSynthesisTasksCommand, "NextToken", "NextToken", "MaxResults");
-// Annotate the CommonJS export names for ESM import in node:
+const paginateListSpeechSynthesisTasks = core.createPaginator(PollyClient, ListSpeechSynthesisTasksCommand, "NextToken", "NextToken", "MaxResults");
-0 && (module.exports = {
-  PollyServiceException,
-  __Client,
-  PollyClient,
-  Polly,
-  $Command,
-  DeleteLexiconCommand,
-  DescribeVoicesCommand,
-  GetLexiconCommand,
-  GetSpeechSynthesisTaskCommand,
-  ListLexiconsCommand,
-  ListSpeechSynthesisTasksCommand,
-  PutLexiconCommand,
-  StartSpeechSynthesisTaskCommand,
-  SynthesizeSpeechCommand,
-  paginateListSpeechSynthesisTasks,
-  LexiconNotFoundException,
-  ServiceFailureException,
-  Engine,
-  LanguageCode,
-  Gender,
-  VoiceId,
-  InvalidNextTokenException,
-  EngineNotSupportedException,
-  OutputFormat,
-  SpeechMarkType,
-  TaskStatus,
-  TextType,
-  InvalidTaskIdException,
-  SynthesisTaskNotFoundException,
-  InvalidLexiconException,
-  InvalidS3BucketException,
-  InvalidS3KeyException,
-  InvalidSampleRateException,
-  InvalidSnsTopicArnException,
-  InvalidSsmlException,
-  LanguageNotSupportedException,
-  LexiconSizeExceededException,
-  MarksNotSupportedForFormatException,
-  MaxLexemeLengthExceededException,
-  MaxLexiconsNumberExceededException,
-  UnsupportedPlsAlphabetException,
-  UnsupportedPlsLanguageException,
-  SsmlMarksNotSupportedForTextTypeException,
-  TextLengthExceededException,
-  LexiconFilterSensitiveLog,
-  GetLexiconOutputFilterSensitiveLog,
-  PutLexiconInputFilterSensitiveLog,
-  SynthesizeSpeechOutputFilterSensitiveLog
+Object.defineProperty(exports, "$Command", {
+    enumerable: true,
+    get: function () { return smithyClient.Command; }
 });
+Object.defineProperty(exports, "__Client", {
+    enumerable: true,
+    get: function () { return smithyClient.Client; }
+});
+exports.DeleteLexiconCommand = DeleteLexiconCommand;
+exports.DescribeVoicesCommand = DescribeVoicesCommand;
+exports.Engine = Engine;
+exports.EngineNotSupportedException = EngineNotSupportedException;
+exports.Gender = Gender;
+exports.GetLexiconCommand = GetLexiconCommand;
+exports.GetLexiconOutputFilterSensitiveLog = GetLexiconOutputFilterSensitiveLog;
+exports.GetSpeechSynthesisTaskCommand = GetSpeechSynthesisTaskCommand;
+exports.InvalidLexiconException = InvalidLexiconException;
+exports.InvalidNextTokenException = InvalidNextTokenException;
+exports.InvalidS3BucketException = InvalidS3BucketException;
+exports.InvalidS3KeyException = InvalidS3KeyException;
+exports.InvalidSampleRateException = InvalidSampleRateException;
+exports.InvalidSnsTopicArnException = InvalidSnsTopicArnException;
+exports.InvalidSsmlException = InvalidSsmlException;
+exports.InvalidTaskIdException = InvalidTaskIdException;
+exports.LanguageCode = LanguageCode;
+exports.LanguageNotSupportedException = LanguageNotSupportedException;
+exports.LexiconFilterSensitiveLog = LexiconFilterSensitiveLog;
+exports.LexiconNotFoundException = LexiconNotFoundException;
+exports.LexiconSizeExceededException = LexiconSizeExceededException;
+exports.ListLexiconsCommand = ListLexiconsCommand;
+exports.ListSpeechSynthesisTasksCommand = ListSpeechSynthesisTasksCommand;
+exports.MarksNotSupportedForFormatException = MarksNotSupportedForFormatException;
+exports.MaxLexemeLengthExceededException = MaxLexemeLengthExceededException;
+exports.MaxLexiconsNumberExceededException = MaxLexiconsNumberExceededException;
+exports.OutputFormat = OutputFormat;
+exports.Polly = Polly;
+exports.PollyClient = PollyClient;
+exports.PollyServiceException = PollyServiceException;
+exports.PutLexiconCommand = PutLexiconCommand;
+exports.PutLexiconInputFilterSensitiveLog = PutLexiconInputFilterSensitiveLog;
+exports.ServiceFailureException = ServiceFailureException;
+exports.SpeechMarkType = SpeechMarkType;
+exports.SsmlMarksNotSupportedForTextTypeException = SsmlMarksNotSupportedForTextTypeException;
+exports.StartSpeechSynthesisTaskCommand = StartSpeechSynthesisTaskCommand;
+exports.SynthesisTaskNotFoundException = SynthesisTaskNotFoundException;
+exports.SynthesizeSpeechCommand = SynthesizeSpeechCommand;
+exports.SynthesizeSpeechOutputFilterSensitiveLog = SynthesizeSpeechOutputFilterSensitiveLog;
+exports.TaskStatus = TaskStatus;
+exports.TextLengthExceededException = TextLengthExceededException;
+exports.TextType = TextType;
+exports.UnsupportedPlsAlphabetException = UnsupportedPlsAlphabetException;
+exports.UnsupportedPlsLanguageException = UnsupportedPlsLanguageException;
+exports.VoiceId = VoiceId;
+exports.paginateListSpeechSynthesisTasks = paginateListSpeechSynthesisTasks;