@aws-sdk/client-polly 3.1074.0 → 3.1076.0

package/dist-cjs/index.js

@@ -1,23 +1,60 @@
-var __exportStar = (m, e) => { Object.assign(e, m); };
-const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
 const { resolveEventStreamConfig, getEventStreamPlugin } = require("@aws-sdk/middleware-eventstream");
 const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
-const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
+const { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
 exports.$Command = Command;
 exports.__Client = Client;
-const { resolveRegionConfig } = require("@smithy/core/config");
-const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
-const { resolveEventStreamSerdeConfig } = require("@smithy/core/event-streams");
-const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
-const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
-const { getSchemaSerdePlugin } = require("@smithy/core/schema");
-const { resolveHttpAuthSchemeConfig, defaultPollyHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
-const { getRuntimeConfig } = require("./runtimeConfig");
-const { DeleteLexicon$, DescribeVoices$, GetLexicon$, GetSpeechSynthesisTask$, ListLexicons$, ListSpeechSynthesisTasks$, PutLexicon$, StartSpeechSynthesisStream$, StartSpeechSynthesisTask$, SynthesizeSpeech$ } = require("./schemas/schemas_0");
-__exportStar(require("./schemas/schemas_0"), exports);
-__exportStar(require("./models/errors"), exports);
-const { PollyServiceException } = require("./models/PollyServiceException");
-exports.PollyServiceException = PollyServiceException;
+const { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require("@smithy/core/config");
+const { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { eventStreamSerdeProvider, resolveEventStreamSerdeConfig } = require("@smithy/core/event-streams");
+const { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { TypeRegistry, getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveAwsSdkSigV4Config, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require("@aws-sdk/core/httpAuthSchemes");
+const { defaultProvider } = require("@aws-sdk/credential-provider-node");
+const { eventStreamPayloadHandlerProvider } = require("@aws-sdk/eventstream-handler-node");
+const { toUtf8, fromUtf8, sdkStreamMixin, toBase64, fromBase64, Hash, calculateBodyLength } = require("@smithy/core/serde");
+const { streamCollector, NodeHttp2Handler } = require("@smithy/node-http-handler");
+const { AwsRestJsonProtocol } = require("@aws-sdk/core/protocols");
+
+const defaultPollyHttpAuthSchemeParametersProvider = async (config, context, input) => {
+    return {
+        operation: getSmithyContext(context).operation,
+        region: await normalizeProvider(config.region)() || (() => {
+            throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
+        })(),
+    };
+};
+function createAwsAuthSigv4HttpAuthOption(authParameters) {
+    return {
+        schemeId: "aws.auth#sigv4",
+        signingProperties: {
+            name: "polly",
+            region: authParameters.region,
+        },
+        propertiesExtractor: (config, context) => ({
+            signingProperties: {
+                config,
+                context,
+            },
+        }),
+    };
+}
+const defaultPollyHttpAuthSchemeProvider = (authParameters) => {
+    const options = [];
+    switch (authParameters.operation) {
+        default: {
+            options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
+        }
+    }
+    return options;
+};
+const resolveHttpAuthSchemeConfig = (config) => {
+    const config_0 = resolveAwsSdkSigV4Config(config);
+    return Object.assign(config_0, {
+        authSchemePreference: normalizeProvider(config.authSchemePreference ?? []),
+    });
+};
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -33,6 +70,962 @@ const commonParams = {
     UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
 };
 
+var version = "3.1075.0";
+var packageInfo = {
+	version: version};
+
+const k = "ref";
+const a = -1, b = true, c = "isSet", d = "PartitionResult", e = "booleanEquals", f = "getAttr", g = { [k]: "Endpoint" }, h = { [k]: d }, i = {}, j = [{ [k]: "Region" }];
+const _data = {
+    conditions: [
+        [c, [g]],
+        [c, j],
+        ["aws.partition", j, d],
+        [e, [{ [k]: "UseFIPS" }, b]],
+        [e, [{ [k]: "UseDualStack" }, b]],
+        [e, [{ fn: f, argv: [h, "supportsDualStack"] }, b]],
+        [e, [{ fn: f, argv: [h, "supportsFIPS"] }, b]]
+    ],
+    results: [
+        [a],
+        [a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
+        [a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
+        [g, i],
+        ["https://polly-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        [a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
+        ["https://polly-fips.{Region}.{PartitionResult#dnsSuffix}", i],
+        [a, "FIPS is enabled but this partition does not support FIPS"],
+        ["https://polly.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        [a, "DualStack is enabled but this partition does not support DualStack"],
+        ["https://polly.{Region}.{PartitionResult#dnsSuffix}", i],
+        [a, "Invalid Configuration: Missing Region"]
+    ]
+};
+const root = 2;
+const r = 100_000_000;
+const nodes = new Int32Array([
+    -1, 1, -1,
+    0, 12, 3,
+    1, 4, r + 11,
+    2, 5, r + 11,
+    3, 8, 6,
+    4, 7, r + 10,
+    5, r + 8, r + 9,
+    4, 10, 9,
+    6, r + 6, r + 7,
+    5, 11, r + 5,
+    6, r + 4, r + 5,
+    3, r + 1, 13,
+    4, r + 2, r + 3,
+]);
+const bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
+
+const cache = new EndpointCache({
+    size: 50,
+    params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"],
+});
+const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return cache.get(endpointParams, () => decideEndpoint(bdd, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    }));
+};
+customEndpointFunctions.aws = awsEndpointFunctions;
+
+class PollyServiceException extends ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, PollyServiceException.prototype);
+    }
+}
+
+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);
+    }
+}
+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);
+    }
+}
+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 ServiceQuotaExceededException extends PollyServiceException {
+    name = "ServiceQuotaExceededException";
+    $fault = "client";
+    quotaCode;
+    serviceCode;
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+        this.quotaCode = opts.quotaCode;
+        this.serviceCode = opts.serviceCode;
+    }
+}
+class ThrottlingException extends PollyServiceException {
+    name = "ThrottlingException";
+    $fault = "client";
+    throttlingReasons;
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+        this.throttlingReasons = opts.throttlingReasons;
+    }
+}
+class ValidationException extends PollyServiceException {
+    name = "ValidationException";
+    $fault = "client";
+    reason;
+    fields;
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.reason = opts.reason;
+        this.fields = opts.fields;
+    }
+}
+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 _A = "Alphabet";
+const _AC = "AudioChunk";
+const _AE = "AudioEvent";
+const _ALC = "AdditionalLanguageCodes";
+const _AS = "AudioStream";
+const _ASc = "ActionStream";
+const _At = "Attributes";
+const _C = "Content";
+const _CSE = "CloseStreamEvent";
+const _CT = "CreationTime";
+const _CT_ = "Content-Type";
+const _CTo = "ContentType";
+const _DL = "DeleteLexicon";
+const _DLI = "DeleteLexiconInput";
+const _DLO = "DeleteLexiconOutput";
+const _DV = "DescribeVoices";
+const _DVI = "DescribeVoicesInput";
+const _DVO = "DescribeVoicesOutput";
+const _E = "Engine";
+const _ENSE = "EngineNotSupportedException";
+const _ES = "EventStream";
+const _F = "Force";
+const _FSC = "FlushStreamConfiguration";
+const _G = "Gender";
+const _GL = "GetLexicon";
+const _GLI = "GetLexiconInput";
+const _GLO = "GetLexiconOutput";
+const _GSST = "GetSpeechSynthesisTask";
+const _GSSTI = "GetSpeechSynthesisTaskInput";
+const _GSSTO = "GetSpeechSynthesisTaskOutput";
+const _I = "Id";
+const _IALC = "IncludeAdditionalLanguageCodes";
+const _ILE = "InvalidLexiconException";
+const _INTE = "InvalidNextTokenException";
+const _ISBE = "InvalidS3BucketException";
+const _ISE = "InvalidSsmlException";
+const _ISKE = "InvalidS3KeyException";
+const _ISRE = "InvalidSampleRateException";
+const _ISTAE = "InvalidSnsTopicArnException";
+const _ITIE = "InvalidTaskIdException";
+const _L = "Lexicon";
+const _LA = "LexiconAttributes";
+const _LAe = "LexiconArn";
+const _LC = "LexiconContent";
+const _LCa = "LanguageCode";
+const _LCe = "LexemesCount";
+const _LD = "LexiconDescription";
+const _LDL = "LexiconDescriptionList";
+const _LL = "ListLexicons";
+const _LLI = "ListLexiconsInput";
+const _LLO = "ListLexiconsOutput";
+const _LM = "LastModified";
+const _LN = "LexiconNames";
+const _LNFE = "LexiconNotFoundException";
+const _LNSE = "LanguageNotSupportedException";
+const _LNa = "LanguageName";
+const _LSEE = "LexiconSizeExceededException";
+const _LSST = "ListSpeechSynthesisTasks";
+const _LSSTI = "ListSpeechSynthesisTasksInput";
+const _LSSTO = "ListSpeechSynthesisTasksOutput";
+const _Le = "Lexicons";
+const _MLLEE = "MaxLexemeLengthExceededException";
+const _MLNEE = "MaxLexiconsNumberExceededException";
+const _MNSFFE = "MarksNotSupportedForFormatException";
+const _MR = "MaxResults";
+const _N = "Name";
+const _NT = "NextToken";
+const _OF = "OutputFormat";
+const _OSBN = "OutputS3BucketName";
+const _OSKP = "OutputS3KeyPrefix";
+const _OU = "OutputUri";
+const _PL = "PutLexicon";
+const _PLI = "PutLexiconInput";
+const _PLO = "PutLexiconOutput";
+const _RC = "RequestCharacters";
+const _S = "Size";
+const _SCE = "StreamClosedEvent";
+const _SE = "SupportedEngines";
+const _SFE = "ServiceFailureException";
+const _SMNSFTTE = "SsmlMarksNotSupportedForTextTypeException";
+const _SMT = "SpeechMarkTypes";
+const _SQEE = "ServiceQuotaExceededException";
+const _SR = "SampleRate";
+const _SS = "SynthesizeSpeech";
+const _SSI = "SynthesizeSpeechInput";
+const _SSO = "SynthesizeSpeechOutput";
+const _SSSS = "StartSpeechSynthesisStream";
+const _SSSSAS = "StartSpeechSynthesisStreamActionStream";
+const _SSSSES = "StartSpeechSynthesisStreamEventStream";
+const _SSSSI = "StartSpeechSynthesisStreamInput";
+const _SSSSO = "StartSpeechSynthesisStreamOutput";
+const _SSST = "StartSpeechSynthesisTask";
+const _SSSTI = "StartSpeechSynthesisTaskInput";
+const _SSSTO = "StartSpeechSynthesisTaskOutput";
+const _ST = "SynthesisTask";
+const _STA = "SnsTopicArn";
+const _STNFE = "SynthesisTaskNotFoundException";
+const _STy = "SynthesisTasks";
+const _St = "Status";
+const _T = "Text";
+const _TE = "ThrottlingException";
+const _TEe = "TextEvent";
+const _TI = "TaskId";
+const _TLEE = "TextLengthExceededException";
+const _TR = "ThrottlingReason";
+const _TRL = "ThrottlingReasonList";
+const _TS = "TaskStatus";
+const _TSR = "TaskStatusReason";
+const _TT = "TextType";
+const _UPAE = "UnsupportedPlsAlphabetException";
+const _UPLE = "UnsupportedPlsLanguageException";
+const _V = "Voices";
+const _VE = "ValidationException";
+const _VEF = "ValidationExceptionField";
+const _VEFL = "ValidationExceptionFieldList";
+const _VI = "VoiceId";
+const _VL = "VoiceList";
+const _Vo = "Voice";
+const _aQE = "awsQueryError";
+const _c = "client";
+const _e = "error";
+const _eP = "eventPayload";
+const _f = "fields";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _hQ = "httpQuery";
+const _m = "message";
+const _n = "name";
+const _qC = "quotaCode";
+const _r = "reason";
+const _re = "resource";
+const _s = "smithy.ts.sdk.synthetic.com.amazonaws.polly";
+const _sC = "serviceCode";
+const _se = "server";
+const _st = "streaming";
+const _tR = "throttlingReasons";
+const _xaE = "x-amzn-Engine";
+const _xaL = "x-amzn-LanguageCode";
+const _xaL_ = "x-amzn-LexiconNames";
+const _xaO = "x-amzn-OutputFormat";
+const _xaR = "x-amzn-RequestCharacters";
+const _xaS = "x-amzn-SampleRate";
+const _xaV = "x-amzn-VoiceId";
+const n0 = "com.amazonaws.polly";
+const _s_registry = TypeRegistry.for(_s);
+var PollyServiceException$ = [-3, _s, "PollyServiceException", 0, [], []];
+_s_registry.registerError(PollyServiceException$, PollyServiceException);
+const n0_registry = TypeRegistry.for(n0);
+var EngineNotSupportedException$ = [-3, n0, _ENSE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(EngineNotSupportedException$, EngineNotSupportedException);
+var InvalidLexiconException$ = [-3, n0, _ILE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidLexiconException$, InvalidLexiconException);
+var InvalidNextTokenException$ = [-3, n0, _INTE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidNextTokenException$, InvalidNextTokenException);
+var InvalidS3BucketException$ = [-3, n0, _ISBE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidS3BucketException$, InvalidS3BucketException);
+var InvalidS3KeyException$ = [-3, n0, _ISKE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidS3KeyException$, InvalidS3KeyException);
+var InvalidSampleRateException$ = [-3, n0, _ISRE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidSampleRateException$, InvalidSampleRateException);
+var InvalidSnsTopicArnException$ = [-3, n0, _ISTAE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidSnsTopicArnException$, InvalidSnsTopicArnException);
+var InvalidSsmlException$ = [-3, n0, _ISE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidSsmlException$, InvalidSsmlException);
+var InvalidTaskIdException$ = [-3, n0, _ITIE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidTaskIdException$, InvalidTaskIdException);
+var LanguageNotSupportedException$ = [-3, n0, _LNSE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(LanguageNotSupportedException$, LanguageNotSupportedException);
+var LexiconNotFoundException$ = [-3, n0, _LNFE,
+    { [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(LexiconNotFoundException$, LexiconNotFoundException);
+var LexiconSizeExceededException$ = [-3, n0, _LSEE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(LexiconSizeExceededException$, LexiconSizeExceededException);
+var MarksNotSupportedForFormatException$ = [-3, n0, _MNSFFE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(MarksNotSupportedForFormatException$, MarksNotSupportedForFormatException);
+var MaxLexemeLengthExceededException$ = [-3, n0, _MLLEE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(MaxLexemeLengthExceededException$, MaxLexemeLengthExceededException);
+var MaxLexiconsNumberExceededException$ = [-3, n0, _MLNEE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(MaxLexiconsNumberExceededException$, MaxLexiconsNumberExceededException);
+var ServiceFailureException$ = [-3, n0, _SFE,
+    { [_e]: _se, [_hE]: 500 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ServiceFailureException$, ServiceFailureException);
+var ServiceQuotaExceededException$ = [-3, n0, _SQEE,
+    { [_e]: _c, [_hE]: 402 },
+    [_m, _qC, _sC],
+    [0, 0, 0], 3
+];
+n0_registry.registerError(ServiceQuotaExceededException$, ServiceQuotaExceededException);
+var SsmlMarksNotSupportedForTextTypeException$ = [-3, n0, _SMNSFTTE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(SsmlMarksNotSupportedForTextTypeException$, SsmlMarksNotSupportedForTextTypeException);
+var SynthesisTaskNotFoundException$ = [-3, n0, _STNFE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(SynthesisTaskNotFoundException$, SynthesisTaskNotFoundException);
+var TextLengthExceededException$ = [-3, n0, _TLEE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(TextLengthExceededException$, TextLengthExceededException);
+var ThrottlingException$ = [-3, n0, _TE,
+    { [_aQE]: [`Throttling`, 400], [_e]: _c, [_hE]: 400 },
+    [_m, _tR],
+    [0, () => ThrottlingReasonList]
+];
+n0_registry.registerError(ThrottlingException$, ThrottlingException);
+var UnsupportedPlsAlphabetException$ = [-3, n0, _UPAE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(UnsupportedPlsAlphabetException$, UnsupportedPlsAlphabetException);
+var UnsupportedPlsLanguageException$ = [-3, n0, _UPLE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(UnsupportedPlsLanguageException$, UnsupportedPlsLanguageException);
+var ValidationException$ = [-3, n0, _VE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m, _r, _f],
+    [0, 0, () => ValidationExceptionFieldList], 2
+];
+n0_registry.registerError(ValidationException$, ValidationException);
+const errorTypeRegistries = [
+    _s_registry,
+    n0_registry,
+];
+var AudioStream = [0, n0, _AS, { [_st]: 1 }, 42];
+var LexiconContent = [0, n0, _LC, 8, 0];
+var AudioEvent$ = [3, n0, _AE,
+    0,
+    [_AC],
+    [[21, { [_eP]: 1 }]]
+];
+var CloseStreamEvent$ = [3, n0, _CSE,
+    0,
+    [],
+    []
+];
+var DeleteLexiconInput$ = [3, n0, _DLI,
+    0,
+    [_N],
+    [[0, 1]], 1
+];
+var DeleteLexiconOutput$ = [3, n0, _DLO,
+    0,
+    [],
+    []
+];
+var DescribeVoicesInput$ = [3, n0, _DVI,
+    0,
+    [_E, _LCa, _IALC, _NT],
+    [[0, { [_hQ]: _E }], [0, { [_hQ]: _LCa }], [2, { [_hQ]: _IALC }], [0, { [_hQ]: _NT }]]
+];
+var DescribeVoicesOutput$ = [3, n0, _DVO,
+    0,
+    [_V, _NT],
+    [() => VoiceList, 0]
+];
+var FlushStreamConfiguration$ = [3, n0, _FSC,
+    0,
+    [_F],
+    [2]
+];
+var GetLexiconInput$ = [3, n0, _GLI,
+    0,
+    [_N],
+    [[0, 1]], 1
+];
+var GetLexiconOutput$ = [3, n0, _GLO,
+    0,
+    [_L, _LA],
+    [[() => Lexicon$, 0], () => LexiconAttributes$]
+];
+var GetSpeechSynthesisTaskInput$ = [3, n0, _GSSTI,
+    0,
+    [_TI],
+    [[0, 1]], 1
+];
+var GetSpeechSynthesisTaskOutput$ = [3, n0, _GSSTO,
+    0,
+    [_ST],
+    [() => SynthesisTask$]
+];
+var Lexicon$ = [3, n0, _L,
+    0,
+    [_C, _N],
+    [[() => LexiconContent, 0], 0]
+];
+var LexiconAttributes$ = [3, n0, _LA,
+    0,
+    [_A, _LCa, _LM, _LAe, _LCe, _S],
+    [0, 0, 4, 0, 1, 1]
+];
+var LexiconDescription$ = [3, n0, _LD,
+    0,
+    [_N, _At],
+    [0, () => LexiconAttributes$]
+];
+var ListLexiconsInput$ = [3, n0, _LLI,
+    0,
+    [_NT],
+    [[0, { [_hQ]: _NT }]]
+];
+var ListLexiconsOutput$ = [3, n0, _LLO,
+    0,
+    [_Le, _NT],
+    [() => LexiconDescriptionList, 0]
+];
+var ListSpeechSynthesisTasksInput$ = [3, n0, _LSSTI,
+    0,
+    [_MR, _NT, _St],
+    [[1, { [_hQ]: _MR }], [0, { [_hQ]: _NT }], [0, { [_hQ]: _St }]]
+];
+var ListSpeechSynthesisTasksOutput$ = [3, n0, _LSSTO,
+    0,
+    [_NT, _STy],
+    [0, () => SynthesisTasks]
+];
+var PutLexiconInput$ = [3, n0, _PLI,
+    0,
+    [_N, _C],
+    [[0, 1], [() => LexiconContent, 0]], 2
+];
+var PutLexiconOutput$ = [3, n0, _PLO,
+    0,
+    [],
+    []
+];
+var StartSpeechSynthesisStreamInput$ = [3, n0, _SSSSI,
+    0,
+    [_E, _OF, _VI, _LCa, _LN, _SR, _ASc],
+    [[0, { [_hH]: _xaE }], [0, { [_hH]: _xaO }], [0, { [_hH]: _xaV }], [0, { [_hH]: _xaL }], [64 | 0, { [_hH]: _xaL_ }], [0, { [_hH]: _xaS }], [() => StartSpeechSynthesisStreamActionStream$, 16]], 3
+];
+var StartSpeechSynthesisStreamOutput$ = [3, n0, _SSSSO,
+    0,
+    [_ES],
+    [[() => StartSpeechSynthesisStreamEventStream$, 16]]
+];
+var StartSpeechSynthesisTaskInput$ = [3, n0, _SSSTI,
+    0,
+    [_OF, _OSBN, _T, _VI, _E, _LCa, _LN, _OSKP, _SR, _STA, _SMT, _TT],
+    [0, 0, 0, 0, 0, 0, 64 | 0, 0, 0, 0, 64 | 0, 0], 4
+];
+var StartSpeechSynthesisTaskOutput$ = [3, n0, _SSSTO,
+    0,
+    [_ST],
+    [() => SynthesisTask$]
+];
+var StreamClosedEvent$ = [3, n0, _SCE,
+    0,
+    [_RC],
+    [1]
+];
+var SynthesisTask$ = [3, n0, _ST,
+    0,
+    [_E, _TI, _TS, _TSR, _OU, _CT, _RC, _STA, _LN, _OF, _SR, _SMT, _TT, _VI, _LCa],
+    [0, 0, 0, 0, 0, 4, 1, 0, 64 | 0, 0, 0, 64 | 0, 0, 0, 0]
+];
+var SynthesizeSpeechInput$ = [3, n0, _SSI,
+    0,
+    [_OF, _T, _VI, _E, _LCa, _LN, _SR, _SMT, _TT],
+    [0, 0, 0, 0, 0, 64 | 0, 0, 64 | 0, 0], 3
+];
+var SynthesizeSpeechOutput$ = [3, n0, _SSO,
+    0,
+    [_AS, _CTo, _RC],
+    [[() => AudioStream, 16], [0, { [_hH]: _CT_ }], [1, { [_hH]: _xaR }]]
+];
+var TextEvent$ = [3, n0, _TEe,
+    0,
+    [_T, _TT, _FSC],
+    [0, 0, () => FlushStreamConfiguration$], 1
+];
+var ThrottlingReason$ = [3, n0, _TR,
+    0,
+    [_r, _re],
+    [0, 0]
+];
+var ValidationExceptionField$ = [3, n0, _VEF,
+    0,
+    [_n, _m],
+    [0, 0], 2
+];
+var Voice$ = [3, n0, _Vo,
+    0,
+    [_G, _I, _LCa, _LNa, _N, _ALC, _SE],
+    [0, 0, 0, 0, 0, 64 | 0, 64 | 0]
+];
+var LexiconDescriptionList = [1, n0, _LDL,
+    0, () => LexiconDescription$
+];
+var SynthesisTasks = [1, n0, _STy,
+    0, () => SynthesisTask$
+];
+var ThrottlingReasonList = [1, n0, _TRL,
+    0, () => ThrottlingReason$
+];
+var ValidationExceptionFieldList = [1, n0, _VEFL,
+    0, () => ValidationExceptionField$
+];
+var VoiceList = [1, n0, _VL,
+    0, () => Voice$
+];
+var StartSpeechSynthesisStreamActionStream$ = [4, n0, _SSSSAS,
+    { [_st]: 1 },
+    [_TEe, _CSE],
+    [() => TextEvent$, () => CloseStreamEvent$]
+];
+var StartSpeechSynthesisStreamEventStream$ = [4, n0, _SSSSES,
+    { [_st]: 1 },
+    [_AE, _SCE, _VE, _SQEE, _SFE, _TE],
+    [[() => AudioEvent$, 0], () => StreamClosedEvent$, [() => ValidationException$, 0], [() => ServiceQuotaExceededException$, 0], [() => ServiceFailureException$, 0], [() => ThrottlingException$, 0]]
+];
+var DeleteLexicon$ = [9, n0, _DL,
+    { [_h]: ["DELETE", "/v1/lexicons/{Name}", 200] }, () => DeleteLexiconInput$, () => DeleteLexiconOutput$
+];
+var DescribeVoices$ = [9, n0, _DV,
+    { [_h]: ["GET", "/v1/voices", 200] }, () => DescribeVoicesInput$, () => DescribeVoicesOutput$
+];
+var GetLexicon$ = [9, n0, _GL,
+    { [_h]: ["GET", "/v1/lexicons/{Name}", 200] }, () => GetLexiconInput$, () => GetLexiconOutput$
+];
+var GetSpeechSynthesisTask$ = [9, n0, _GSST,
+    { [_h]: ["GET", "/v1/synthesisTasks/{TaskId}", 200] }, () => GetSpeechSynthesisTaskInput$, () => GetSpeechSynthesisTaskOutput$
+];
+var ListLexicons$ = [9, n0, _LL,
+    { [_h]: ["GET", "/v1/lexicons", 200] }, () => ListLexiconsInput$, () => ListLexiconsOutput$
+];
+var ListSpeechSynthesisTasks$ = [9, n0, _LSST,
+    { [_h]: ["GET", "/v1/synthesisTasks", 200] }, () => ListSpeechSynthesisTasksInput$, () => ListSpeechSynthesisTasksOutput$
+];
+var PutLexicon$ = [9, n0, _PL,
+    { [_h]: ["PUT", "/v1/lexicons/{Name}", 200] }, () => PutLexiconInput$, () => PutLexiconOutput$
+];
+var StartSpeechSynthesisStream$ = [9, n0, _SSSS,
+    { [_h]: ["POST", "/v1/synthesisStream", 200] }, () => StartSpeechSynthesisStreamInput$, () => StartSpeechSynthesisStreamOutput$
+];
+var StartSpeechSynthesisTask$ = [9, n0, _SSST,
+    { [_h]: ["POST", "/v1/synthesisTasks", 200] }, () => StartSpeechSynthesisTaskInput$, () => StartSpeechSynthesisTaskOutput$
+];
+var SynthesizeSpeech$ = [9, n0, _SS,
+    { [_h]: ["POST", "/v1/speech", 200] }, () => SynthesizeSpeechInput$, () => SynthesizeSpeechOutput$
+];
+
+const getRuntimeConfig$1 = (config) => {
+    return {
+        apiVersion: "2016-06-10",
+        base64Decoder: config?.base64Decoder ?? fromBase64,
+        base64Encoder: config?.base64Encoder ?? toBase64,
+        disableHostPrefix: config?.disableHostPrefix ?? false,
+        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+        extensions: config?.extensions ?? [],
+        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultPollyHttpAuthSchemeProvider,
+        httpAuthSchemes: config?.httpAuthSchemes ?? [
+            {
+                schemeId: "aws.auth#sigv4",
+                identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
+                signer: new AwsSdkSigV4Signer(),
+            },
+        ],
+        logger: config?.logger ?? new NoOpLogger(),
+        protocol: config?.protocol ?? AwsRestJsonProtocol,
+        protocolSettings: config?.protocolSettings ?? {
+            defaultNamespace: "com.amazonaws.polly",
+            errorTypeRegistries,
+            xmlNamespace: "http://polly.amazonaws.com/doc/v1",
+            version: "2016-06-10",
+            serviceTarget: "Parrot_v1",
+        },
+        sdkStreamMixin: config?.sdkStreamMixin ?? sdkStreamMixin,
+        serviceId: config?.serviceId ?? "Polly",
+        urlParser: config?.urlParser ?? parseUrl,
+        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+        utf8Encoder: config?.utf8Encoder ?? toUtf8,
+    };
+};
+
+const getRuntimeConfig = (config) => {
+    emitWarningIfUnsupportedVersion(process.version);
+    const defaultsMode = resolveDefaultsModeConfig(config);
+    const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+    const clientSharedValues = getRuntimeConfig$1(config);
+    emitWarningIfUnsupportedVersion$1(process.version);
+    const loaderConfig = {
+        profile: config?.profile,
+        logger: clientSharedValues.logger,
+    };
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "node",
+        defaultsMode,
+        authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
+        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        eventStreamPayloadHandlerProvider: config?.eventStreamPayloadHandlerProvider ?? eventStreamPayloadHandlerProvider,
+        eventStreamSerdeProvider: config?.eventStreamSerdeProvider ?? eventStreamSerdeProvider,
+        maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
+        region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
+        requestHandler: NodeHttp2Handler.create(config?.requestHandler ?? (async () => ({
+            ...await defaultConfigProvider(),
+            disableConcurrentStreams: true
+        }))),
+        retryMode: config?.retryMode ??
+            loadConfig({
+                ...NODE_RETRY_MODE_CONFIG_OPTIONS,
+                default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE,
+            }, config),
+        sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
+        streamCollector: config?.streamCollector ?? streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig),
+    };
+};
+
 const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
     const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
     let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
@@ -465,27 +1458,122 @@ const ValidationExceptionReason = {
     UNSUPPORTED_OPERATION: "unsupportedOperation",
 };
 
+exports.AudioEvent$ = AudioEvent$;
+exports.CloseStreamEvent$ = CloseStreamEvent$;
+exports.DeleteLexicon$ = DeleteLexicon$;
 exports.DeleteLexiconCommand = DeleteLexiconCommand;
+exports.DeleteLexiconInput$ = DeleteLexiconInput$;
+exports.DeleteLexiconOutput$ = DeleteLexiconOutput$;
+exports.DescribeVoices$ = DescribeVoices$;
 exports.DescribeVoicesCommand = DescribeVoicesCommand;
+exports.DescribeVoicesInput$ = DescribeVoicesInput$;
+exports.DescribeVoicesOutput$ = DescribeVoicesOutput$;
 exports.Engine = Engine;
+exports.EngineNotSupportedException = EngineNotSupportedException;
+exports.EngineNotSupportedException$ = EngineNotSupportedException$;
+exports.FlushStreamConfiguration$ = FlushStreamConfiguration$;
 exports.Gender = Gender;
+exports.GetLexicon$ = GetLexicon$;
 exports.GetLexiconCommand = GetLexiconCommand;
+exports.GetLexiconInput$ = GetLexiconInput$;
+exports.GetLexiconOutput$ = GetLexiconOutput$;
+exports.GetSpeechSynthesisTask$ = GetSpeechSynthesisTask$;
 exports.GetSpeechSynthesisTaskCommand = GetSpeechSynthesisTaskCommand;
+exports.GetSpeechSynthesisTaskInput$ = GetSpeechSynthesisTaskInput$;
+exports.GetSpeechSynthesisTaskOutput$ = GetSpeechSynthesisTaskOutput$;
+exports.InvalidLexiconException = InvalidLexiconException;
+exports.InvalidLexiconException$ = InvalidLexiconException$;
+exports.InvalidNextTokenException = InvalidNextTokenException;
+exports.InvalidNextTokenException$ = InvalidNextTokenException$;
+exports.InvalidS3BucketException = InvalidS3BucketException;
+exports.InvalidS3BucketException$ = InvalidS3BucketException$;
+exports.InvalidS3KeyException = InvalidS3KeyException;
+exports.InvalidS3KeyException$ = InvalidS3KeyException$;
+exports.InvalidSampleRateException = InvalidSampleRateException;
+exports.InvalidSampleRateException$ = InvalidSampleRateException$;
+exports.InvalidSnsTopicArnException = InvalidSnsTopicArnException;
+exports.InvalidSnsTopicArnException$ = InvalidSnsTopicArnException$;
+exports.InvalidSsmlException = InvalidSsmlException;
+exports.InvalidSsmlException$ = InvalidSsmlException$;
+exports.InvalidTaskIdException = InvalidTaskIdException;
+exports.InvalidTaskIdException$ = InvalidTaskIdException$;
 exports.LanguageCode = LanguageCode;
+exports.LanguageNotSupportedException = LanguageNotSupportedException;
+exports.LanguageNotSupportedException$ = LanguageNotSupportedException$;
+exports.Lexicon$ = Lexicon$;
+exports.LexiconAttributes$ = LexiconAttributes$;
+exports.LexiconDescription$ = LexiconDescription$;
+exports.LexiconNotFoundException = LexiconNotFoundException;
+exports.LexiconNotFoundException$ = LexiconNotFoundException$;
+exports.LexiconSizeExceededException = LexiconSizeExceededException;
+exports.LexiconSizeExceededException$ = LexiconSizeExceededException$;
+exports.ListLexicons$ = ListLexicons$;
 exports.ListLexiconsCommand = ListLexiconsCommand;
+exports.ListLexiconsInput$ = ListLexiconsInput$;
+exports.ListLexiconsOutput$ = ListLexiconsOutput$;
+exports.ListSpeechSynthesisTasks$ = ListSpeechSynthesisTasks$;
 exports.ListSpeechSynthesisTasksCommand = ListSpeechSynthesisTasksCommand;
+exports.ListSpeechSynthesisTasksInput$ = ListSpeechSynthesisTasksInput$;
+exports.ListSpeechSynthesisTasksOutput$ = ListSpeechSynthesisTasksOutput$;
+exports.MarksNotSupportedForFormatException = MarksNotSupportedForFormatException;
+exports.MarksNotSupportedForFormatException$ = MarksNotSupportedForFormatException$;
+exports.MaxLexemeLengthExceededException = MaxLexemeLengthExceededException;
+exports.MaxLexemeLengthExceededException$ = MaxLexemeLengthExceededException$;
+exports.MaxLexiconsNumberExceededException = MaxLexiconsNumberExceededException;
+exports.MaxLexiconsNumberExceededException$ = MaxLexiconsNumberExceededException$;
 exports.OutputFormat = OutputFormat;
 exports.Polly = Polly;
 exports.PollyClient = PollyClient;
+exports.PollyServiceException = PollyServiceException;
+exports.PollyServiceException$ = PollyServiceException$;
+exports.PutLexicon$ = PutLexicon$;
 exports.PutLexiconCommand = PutLexiconCommand;
+exports.PutLexiconInput$ = PutLexiconInput$;
+exports.PutLexiconOutput$ = PutLexiconOutput$;
 exports.QuotaCode = QuotaCode;
 exports.ServiceCode = ServiceCode;
+exports.ServiceFailureException = ServiceFailureException;
+exports.ServiceFailureException$ = ServiceFailureException$;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException$ = ServiceQuotaExceededException$;
 exports.SpeechMarkType = SpeechMarkType;
+exports.SsmlMarksNotSupportedForTextTypeException = SsmlMarksNotSupportedForTextTypeException;
+exports.SsmlMarksNotSupportedForTextTypeException$ = SsmlMarksNotSupportedForTextTypeException$;
+exports.StartSpeechSynthesisStream$ = StartSpeechSynthesisStream$;
+exports.StartSpeechSynthesisStreamActionStream$ = StartSpeechSynthesisStreamActionStream$;
 exports.StartSpeechSynthesisStreamCommand = StartSpeechSynthesisStreamCommand;
+exports.StartSpeechSynthesisStreamEventStream$ = StartSpeechSynthesisStreamEventStream$;
+exports.StartSpeechSynthesisStreamInput$ = StartSpeechSynthesisStreamInput$;
+exports.StartSpeechSynthesisStreamOutput$ = StartSpeechSynthesisStreamOutput$;
+exports.StartSpeechSynthesisTask$ = StartSpeechSynthesisTask$;
 exports.StartSpeechSynthesisTaskCommand = StartSpeechSynthesisTaskCommand;
+exports.StartSpeechSynthesisTaskInput$ = StartSpeechSynthesisTaskInput$;
+exports.StartSpeechSynthesisTaskOutput$ = StartSpeechSynthesisTaskOutput$;
+exports.StreamClosedEvent$ = StreamClosedEvent$;
+exports.SynthesisTask$ = SynthesisTask$;
+exports.SynthesisTaskNotFoundException = SynthesisTaskNotFoundException;
+exports.SynthesisTaskNotFoundException$ = SynthesisTaskNotFoundException$;
+exports.SynthesizeSpeech$ = SynthesizeSpeech$;
 exports.SynthesizeSpeechCommand = SynthesizeSpeechCommand;
+exports.SynthesizeSpeechInput$ = SynthesizeSpeechInput$;
+exports.SynthesizeSpeechOutput$ = SynthesizeSpeechOutput$;
 exports.TaskStatus = TaskStatus;
+exports.TextEvent$ = TextEvent$;
+exports.TextLengthExceededException = TextLengthExceededException;
+exports.TextLengthExceededException$ = TextLengthExceededException$;
 exports.TextType = TextType;
+exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException$ = ThrottlingException$;
+exports.ThrottlingReason$ = ThrottlingReason$;
+exports.UnsupportedPlsAlphabetException = UnsupportedPlsAlphabetException;
+exports.UnsupportedPlsAlphabetException$ = UnsupportedPlsAlphabetException$;
+exports.UnsupportedPlsLanguageException = UnsupportedPlsLanguageException;
+exports.UnsupportedPlsLanguageException$ = UnsupportedPlsLanguageException$;
+exports.ValidationException = ValidationException;
+exports.ValidationException$ = ValidationException$;
+exports.ValidationExceptionField$ = ValidationExceptionField$;
 exports.ValidationExceptionReason = ValidationExceptionReason;
+exports.Voice$ = Voice$;
 exports.VoiceId = VoiceId;
+exports.errorTypeRegistries = errorTypeRegistries;
 exports.paginateListSpeechSynthesisTasks = paginateListSpeechSynthesisTasks;