@aws-sdk/client-polly 3.928.0 → 3.930.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ 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');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class PollyClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -110,14 +110,14 @@ class PollyClient extends smithyClient.Client {
     }
 }
 
-class PollyServiceException extends smithyClient.ServiceException {
+let PollyServiceException$1 = class PollyServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, PollyServiceException.prototype);
     }
-}
+};
 
-class LexiconNotFoundException extends PollyServiceException {
+let LexiconNotFoundException$1 = class LexiconNotFoundException extends PollyServiceException$1 {
     name = "LexiconNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -128,8 +128,8 @@ class LexiconNotFoundException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, LexiconNotFoundException.prototype);
     }
-}
-class ServiceFailureException extends PollyServiceException {
+};
+let ServiceFailureException$1 = class ServiceFailureException extends PollyServiceException$1 {
     name = "ServiceFailureException";
     $fault = "server";
     constructor(opts) {
@@ -140,7 +140,7 @@ class ServiceFailureException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, ServiceFailureException.prototype);
     }
-}
+};
 const Engine = {
     GENERATIVE: "generative",
     LONG_FORM: "long-form",
@@ -297,7 +297,7 @@ const VoiceId = {
     Zeina: "Zeina",
     Zhiyu: "Zhiyu",
 };
-class InvalidNextTokenException extends PollyServiceException {
+let InvalidNextTokenException$1 = class InvalidNextTokenException extends PollyServiceException$1 {
     name = "InvalidNextTokenException";
     $fault = "client";
     constructor(opts) {
@@ -308,8 +308,8 @@ class InvalidNextTokenException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, InvalidNextTokenException.prototype);
     }
-}
-class EngineNotSupportedException extends PollyServiceException {
+};
+let EngineNotSupportedException$1 = class EngineNotSupportedException extends PollyServiceException$1 {
     name = "EngineNotSupportedException";
     $fault = "client";
     constructor(opts) {
@@ -320,7 +320,7 @@ class EngineNotSupportedException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, EngineNotSupportedException.prototype);
     }
-}
+};
 const OutputFormat = {
     JSON: "json",
     MP3: "mp3",
@@ -344,7 +344,7 @@ const TextType = {
     SSML: "ssml",
     TEXT: "text",
 };
-class InvalidTaskIdException extends PollyServiceException {
+let InvalidTaskIdException$1 = class InvalidTaskIdException extends PollyServiceException$1 {
     name = "InvalidTaskIdException";
     $fault = "client";
     constructor(opts) {
@@ -355,8 +355,8 @@ class InvalidTaskIdException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, InvalidTaskIdException.prototype);
     }
-}
-class SynthesisTaskNotFoundException extends PollyServiceException {
+};
+let SynthesisTaskNotFoundException$1 = class SynthesisTaskNotFoundException extends PollyServiceException$1 {
     name = "SynthesisTaskNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -367,8 +367,8 @@ class SynthesisTaskNotFoundException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, SynthesisTaskNotFoundException.prototype);
     }
-}
-class InvalidLexiconException extends PollyServiceException {
+};
+let InvalidLexiconException$1 = class InvalidLexiconException extends PollyServiceException$1 {
     name = "InvalidLexiconException";
     $fault = "client";
     constructor(opts) {
@@ -379,8 +379,8 @@ class InvalidLexiconException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, InvalidLexiconException.prototype);
     }
-}
-class InvalidS3BucketException extends PollyServiceException {
+};
+let InvalidS3BucketException$1 = class InvalidS3BucketException extends PollyServiceException$1 {
     name = "InvalidS3BucketException";
     $fault = "client";
     constructor(opts) {
@@ -391,8 +391,8 @@ class InvalidS3BucketException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, InvalidS3BucketException.prototype);
     }
-}
-class InvalidS3KeyException extends PollyServiceException {
+};
+let InvalidS3KeyException$1 = class InvalidS3KeyException extends PollyServiceException$1 {
     name = "InvalidS3KeyException";
     $fault = "client";
     constructor(opts) {
@@ -403,8 +403,8 @@ class InvalidS3KeyException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, InvalidS3KeyException.prototype);
     }
-}
-class InvalidSampleRateException extends PollyServiceException {
+};
+let InvalidSampleRateException$1 = class InvalidSampleRateException extends PollyServiceException$1 {
     name = "InvalidSampleRateException";
     $fault = "client";
     constructor(opts) {
@@ -415,8 +415,8 @@ class InvalidSampleRateException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, InvalidSampleRateException.prototype);
     }
-}
-class InvalidSnsTopicArnException extends PollyServiceException {
+};
+let InvalidSnsTopicArnException$1 = class InvalidSnsTopicArnException extends PollyServiceException$1 {
     name = "InvalidSnsTopicArnException";
     $fault = "client";
     constructor(opts) {
@@ -427,8 +427,8 @@ class InvalidSnsTopicArnException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, InvalidSnsTopicArnException.prototype);
     }
-}
-class InvalidSsmlException extends PollyServiceException {
+};
+let InvalidSsmlException$1 = class InvalidSsmlException extends PollyServiceException$1 {
     name = "InvalidSsmlException";
     $fault = "client";
     constructor(opts) {
@@ -439,8 +439,8 @@ class InvalidSsmlException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, InvalidSsmlException.prototype);
     }
-}
-class LanguageNotSupportedException extends PollyServiceException {
+};
+let LanguageNotSupportedException$1 = class LanguageNotSupportedException extends PollyServiceException$1 {
     name = "LanguageNotSupportedException";
     $fault = "client";
     constructor(opts) {
@@ -451,8 +451,8 @@ class LanguageNotSupportedException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, LanguageNotSupportedException.prototype);
     }
-}
-class LexiconSizeExceededException extends PollyServiceException {
+};
+let LexiconSizeExceededException$1 = class LexiconSizeExceededException extends PollyServiceException$1 {
     name = "LexiconSizeExceededException";
     $fault = "client";
     constructor(opts) {
@@ -463,8 +463,8 @@ class LexiconSizeExceededException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, LexiconSizeExceededException.prototype);
     }
-}
-class MarksNotSupportedForFormatException extends PollyServiceException {
+};
+let MarksNotSupportedForFormatException$1 = class MarksNotSupportedForFormatException extends PollyServiceException$1 {
     name = "MarksNotSupportedForFormatException";
     $fault = "client";
     constructor(opts) {
@@ -475,8 +475,8 @@ class MarksNotSupportedForFormatException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, MarksNotSupportedForFormatException.prototype);
     }
-}
-class MaxLexemeLengthExceededException extends PollyServiceException {
+};
+let MaxLexemeLengthExceededException$1 = class MaxLexemeLengthExceededException extends PollyServiceException$1 {
     name = "MaxLexemeLengthExceededException";
     $fault = "client";
     constructor(opts) {
@@ -487,8 +487,8 @@ class MaxLexemeLengthExceededException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, MaxLexemeLengthExceededException.prototype);
     }
-}
-class MaxLexiconsNumberExceededException extends PollyServiceException {
+};
+let MaxLexiconsNumberExceededException$1 = class MaxLexiconsNumberExceededException extends PollyServiceException$1 {
     name = "MaxLexiconsNumberExceededException";
     $fault = "client";
     constructor(opts) {
@@ -499,8 +499,8 @@ class MaxLexiconsNumberExceededException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, MaxLexiconsNumberExceededException.prototype);
     }
-}
-class UnsupportedPlsAlphabetException extends PollyServiceException {
+};
+let UnsupportedPlsAlphabetException$1 = class UnsupportedPlsAlphabetException extends PollyServiceException$1 {
     name = "UnsupportedPlsAlphabetException";
     $fault = "client";
     constructor(opts) {
@@ -511,8 +511,8 @@ class UnsupportedPlsAlphabetException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, UnsupportedPlsAlphabetException.prototype);
     }
-}
-class UnsupportedPlsLanguageException extends PollyServiceException {
+};
+let UnsupportedPlsLanguageException$1 = class UnsupportedPlsLanguageException extends PollyServiceException$1 {
     name = "UnsupportedPlsLanguageException";
     $fault = "client";
     constructor(opts) {
@@ -523,8 +523,8 @@ class UnsupportedPlsLanguageException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, UnsupportedPlsLanguageException.prototype);
     }
-}
-class SsmlMarksNotSupportedForTextTypeException extends PollyServiceException {
+};
+let SsmlMarksNotSupportedForTextTypeException$1 = class SsmlMarksNotSupportedForTextTypeException extends PollyServiceException$1 {
     name = "SsmlMarksNotSupportedForTextTypeException";
     $fault = "client";
     constructor(opts) {
@@ -535,8 +535,8 @@ class SsmlMarksNotSupportedForTextTypeException extends PollyServiceException {
         });
         Object.setPrototypeOf(this, SsmlMarksNotSupportedForTextTypeException.prototype);
     }
-}
-class TextLengthExceededException extends PollyServiceException {
+};
+let TextLengthExceededException$1 = class TextLengthExceededException extends PollyServiceException$1 {
     name = "TextLengthExceededException";
     $fault = "client";
     constructor(opts) {
@@ -547,704 +547,659 @@ class TextLengthExceededException extends PollyServiceException {
         });
         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,
-});
-
-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();
-};
-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();
-};
-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();
-};
-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();
-};
-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();
-};
-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();
-};
-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();
 };
-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();
-};
-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();
-};
-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;
-};
-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;
-};
-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;
-};
-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;
-};
-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;
-};
-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;
-};
-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;
-};
-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;
-};
-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;
-};
-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,
-            });
-    }
-};
-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);
-};
-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);
-};
-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);
-};
-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);
-};
-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);
-};
-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);
-};
-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);
-};
-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);
-};
-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);
-};
-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);
-};
-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);
-};
-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);
-};
-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);
-};
-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);
-};
-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);
-};
-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);
-};
-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 _A = "Alphabet";
+const _ALC = "AdditionalLanguageCodes";
+const _AS = "AudioStream";
+const _At = "Attributes";
+const _C = "Content";
+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 _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 _LC = "LanguageCode";
+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 = "Status";
-const _ct = "content-type";
-const _xar = "x-amzn-requestcharacters";
+const _S = "Size";
+const _SE = "SupportedEngines";
+const _SFE = "ServiceFailureException";
+const _SMNSFTTE = "SsmlMarksNotSupportedForTextTypeException";
+const _SMT = "SpeechMarkTypes";
+const _SR = "SampleRate";
+const _SS = "SynthesizeSpeech";
+const _SSI = "SynthesizeSpeechInput";
+const _SSO = "SynthesizeSpeechOutput";
+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 _TI = "TaskId";
+const _TLEE = "TextLengthExceededException";
+const _TS = "TaskStatus";
+const _TSR = "TaskStatusReason";
+const _TT = "TextType";
+const _UPAE = "UnsupportedPlsAlphabetException";
+const _UPLE = "UnsupportedPlsLanguageException";
+const _V = "Voices";
+const _VI = "VoiceId";
+const _VL = "VoiceList";
+const _Vo = "Voice";
+const _c = "client";
+const _e = "error";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _hQ = "httpQuery";
+const _m = "message";
+const _s = "streaming";
+const _se = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.polly";
+const _xaR = "x-amzn-RequestCharacters";
+const n0 = "com.amazonaws.polly";
+var AudioStream = [
+    0,
+    n0,
+    _AS,
+    {
+        [_s]: 1,
+    },
+    42,
+];
+var LexiconContent = [0, n0, _LC, 8, 0];
+var DeleteLexiconInput = [3, n0, _DLI, 0, [_N], [[0, 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 EngineNotSupportedException = [
+    -3,
+    n0,
+    _ENSE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(EngineNotSupportedException, EngineNotSupportedException$1);
+var GetLexiconInput = [3, n0, _GLI, 0, [_N], [[0, 1]]];
+var GetLexiconOutput = [
+    3,
+    n0,
+    _GLO,
+    0,
+    [_L, _LA],
+    [[() => Lexicon, 0], () => LexiconAttributes],
+];
+var GetSpeechSynthesisTaskInput = [3, n0, _GSSTI, 0, [_TI], [[0, 1]]];
+var GetSpeechSynthesisTaskOutput = [3, n0, _GSSTO, 0, [_ST], [() => SynthesisTask]];
+var InvalidLexiconException = [
+    -3,
+    n0,
+    _ILE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidLexiconException, InvalidLexiconException$1);
+var InvalidNextTokenException = [
+    -3,
+    n0,
+    _INTE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidNextTokenException, InvalidNextTokenException$1);
+var InvalidS3BucketException = [
+    -3,
+    n0,
+    _ISBE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidS3BucketException, InvalidS3BucketException$1);
+var InvalidS3KeyException = [
+    -3,
+    n0,
+    _ISKE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidS3KeyException, InvalidS3KeyException$1);
+var InvalidSampleRateException = [
+    -3,
+    n0,
+    _ISRE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidSampleRateException, InvalidSampleRateException$1);
+var InvalidSnsTopicArnException = [
+    -3,
+    n0,
+    _ISTAE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidSnsTopicArnException, InvalidSnsTopicArnException$1);
+var InvalidSsmlException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidSsmlException, InvalidSsmlException$1);
+var InvalidTaskIdException = [
+    -3,
+    n0,
+    _ITIE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidTaskIdException, InvalidTaskIdException$1);
+var LanguageNotSupportedException = [
+    -3,
+    n0,
+    _LNSE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LanguageNotSupportedException, LanguageNotSupportedException$1);
+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 LexiconNotFoundException = [
+    -3,
+    n0,
+    _LNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LexiconNotFoundException, LexiconNotFoundException$1);
+var LexiconSizeExceededException = [
+    -3,
+    n0,
+    _LSEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LexiconSizeExceededException, LexiconSizeExceededException$1);
+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 MarksNotSupportedForFormatException = [
+    -3,
+    n0,
+    _MNSFFE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(MarksNotSupportedForFormatException, MarksNotSupportedForFormatException$1);
+var MaxLexemeLengthExceededException = [
+    -3,
+    n0,
+    _MLLEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(MaxLexemeLengthExceededException, MaxLexemeLengthExceededException$1);
+var MaxLexiconsNumberExceededException = [
+    -3,
+    n0,
+    _MLNEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(MaxLexiconsNumberExceededException, MaxLexiconsNumberExceededException$1);
+var PutLexiconInput = [
+    3,
+    n0,
+    _PLI,
+    0,
+    [_N, _C],
+    [
+        [0, 1],
+        [() => LexiconContent, 0],
+    ],
+];
+var PutLexiconOutput = [3, n0, _PLO, 0, [], []];
+var ServiceFailureException = [
+    -3,
+    n0,
+    _SFE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceFailureException, ServiceFailureException$1);
+var SsmlMarksNotSupportedForTextTypeException = [
+    -3,
+    n0,
+    _SMNSFTTE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(SsmlMarksNotSupportedForTextTypeException, SsmlMarksNotSupportedForTextTypeException$1);
+var StartSpeechSynthesisTaskInput = [
+    3,
+    n0,
+    _SSSTI,
+    0,
+    [_E, _LCa, _LN, _OF, _OSBN, _OSKP, _SR, _STA, _SMT, _T, _TT, _VI],
+    [0, 0, 64 | 0, 0, 0, 0, 0, 0, 64 | 0, 0, 0, 0],
+];
+var StartSpeechSynthesisTaskOutput = [3, n0, _SSSTO, 0, [_ST], [() => SynthesisTask]];
+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 SynthesisTaskNotFoundException = [
+    -3,
+    n0,
+    _STNFE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(SynthesisTaskNotFoundException, SynthesisTaskNotFoundException$1);
+var SynthesizeSpeechInput = [
+    3,
+    n0,
+    _SSI,
+    0,
+    [_E, _LCa, _LN, _OF, _SR, _SMT, _T, _TT, _VI],
+    [0, 0, 64 | 0, 0, 0, 64 | 0, 0, 0, 0],
+];
+var SynthesizeSpeechOutput = [
+    3,
+    n0,
+    _SSO,
+    0,
+    [_AS, _CTo, _RC],
+    [
+        [() => AudioStream, 16],
+        [
+            0,
+            {
+                [_hH]: _CT_,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _xaR,
+            },
+        ],
+    ],
+];
+var TextLengthExceededException = [
+    -3,
+    n0,
+    _TLEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TextLengthExceededException, TextLengthExceededException$1);
+var UnsupportedPlsAlphabetException = [
+    -3,
+    n0,
+    _UPAE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(UnsupportedPlsAlphabetException, UnsupportedPlsAlphabetException$1);
+var UnsupportedPlsLanguageException = [
+    -3,
+    n0,
+    _UPLE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(UnsupportedPlsLanguageException, UnsupportedPlsLanguageException$1);
+var Voice = [
+    3,
+    n0,
+    _Vo,
+    0,
+    [_G, _I, _LCa, _LNa, _N, _ALC, _SE],
+    [0, 0, 0, 0, 0, 64 | 0, 64 | 0],
+];
+var PollyServiceException = [-3, _sm, "PollyServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(PollyServiceException, PollyServiceException$1);
+var LexiconDescriptionList = [1, n0, _LDL, 0, () => LexiconDescription];
+var SynthesisTasks = [1, n0, _STy, 0, () => SynthesisTask];
+var VoiceList = [1, n0, _VL, 0, () => Voice];
+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 StartSpeechSynthesisTask = [
+    9,
+    n0,
+    _SSST,
+    {
+        [_h]: ["POST", "/v1/synthesisTasks", 200],
+    },
+    () => StartSpeechSynthesisTaskInput,
+    () => StartSpeechSynthesisTaskOutput,
+];
+var SynthesizeSpeech = [
+    9,
+    n0,
+    _SS,
+    {
+        [_h]: ["POST", "/v1/speech", 200],
+    },
+    () => SynthesizeSpeechInput,
+    () => SynthesizeSpeechOutput,
+];
 
 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()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Parrot_v1", "DeleteLexicon", {})
     .n("PollyClient", "DeleteLexiconCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteLexiconCommand)
-    .de(de_DeleteLexiconCommand)
+    .sc(DeleteLexicon)
     .build() {
 }
 
@@ -1252,16 +1207,11 @@ 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()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Parrot_v1", "DescribeVoices", {})
     .n("PollyClient", "DescribeVoicesCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeVoicesCommand)
-    .de(de_DescribeVoicesCommand)
+    .sc(DescribeVoices)
     .build() {
 }
 
@@ -1269,16 +1219,11 @@ 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()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Parrot_v1", "GetLexicon", {})
     .n("PollyClient", "GetLexiconCommand")
-    .f(void 0, GetLexiconOutputFilterSensitiveLog)
-    .ser(se_GetLexiconCommand)
-    .de(de_GetLexiconCommand)
+    .sc(GetLexicon)
     .build() {
 }
 
@@ -1286,16 +1231,11 @@ 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()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Parrot_v1", "GetSpeechSynthesisTask", {})
     .n("PollyClient", "GetSpeechSynthesisTaskCommand")
-    .f(void 0, void 0)
-    .ser(se_GetSpeechSynthesisTaskCommand)
-    .de(de_GetSpeechSynthesisTaskCommand)
+    .sc(GetSpeechSynthesisTask)
     .build() {
 }
 
@@ -1303,16 +1243,11 @@ 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()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Parrot_v1", "ListLexicons", {})
     .n("PollyClient", "ListLexiconsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListLexiconsCommand)
-    .de(de_ListLexiconsCommand)
+    .sc(ListLexicons)
     .build() {
 }
 
@@ -1320,16 +1255,11 @@ 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()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Parrot_v1", "ListSpeechSynthesisTasks", {})
     .n("PollyClient", "ListSpeechSynthesisTasksCommand")
-    .f(void 0, void 0)
-    .ser(se_ListSpeechSynthesisTasksCommand)
-    .de(de_ListSpeechSynthesisTasksCommand)
+    .sc(ListSpeechSynthesisTasks)
     .build() {
 }
 
@@ -1337,16 +1267,11 @@ 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()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Parrot_v1", "PutLexicon", {})
     .n("PollyClient", "PutLexiconCommand")
-    .f(PutLexiconInputFilterSensitiveLog, void 0)
-    .ser(se_PutLexiconCommand)
-    .de(de_PutLexiconCommand)
+    .sc(PutLexicon)
     .build() {
 }
 
@@ -1354,16 +1279,11 @@ 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()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Parrot_v1", "StartSpeechSynthesisTask", {})
     .n("PollyClient", "StartSpeechSynthesisTaskCommand")
-    .f(void 0, void 0)
-    .ser(se_StartSpeechSynthesisTaskCommand)
-    .de(de_StartSpeechSynthesisTaskCommand)
+    .sc(StartSpeechSynthesisTask)
     .build() {
 }
 
@@ -1371,16 +1291,11 @@ 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()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Parrot_v1", "SynthesizeSpeech", {})
     .n("PollyClient", "SynthesizeSpeechCommand")
-    .f(void 0, SynthesizeSpeechOutputFilterSensitiveLog)
-    .ser(se_SynthesizeSpeechCommand)
-    .de(de_SynthesizeSpeechCommand)
+    .sc(SynthesizeSpeech)
     .build() {
 }
 
@@ -1412,46 +1327,42 @@ Object.defineProperty(exports, "__Client", {
 exports.DeleteLexiconCommand = DeleteLexiconCommand;
 exports.DescribeVoicesCommand = DescribeVoicesCommand;
 exports.Engine = Engine;
-exports.EngineNotSupportedException = EngineNotSupportedException;
+exports.EngineNotSupportedException = EngineNotSupportedException$1;
 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.InvalidLexiconException = InvalidLexiconException$1;
+exports.InvalidNextTokenException = InvalidNextTokenException$1;
+exports.InvalidS3BucketException = InvalidS3BucketException$1;
+exports.InvalidS3KeyException = InvalidS3KeyException$1;
+exports.InvalidSampleRateException = InvalidSampleRateException$1;
+exports.InvalidSnsTopicArnException = InvalidSnsTopicArnException$1;
+exports.InvalidSsmlException = InvalidSsmlException$1;
+exports.InvalidTaskIdException = InvalidTaskIdException$1;
 exports.LanguageCode = LanguageCode;
-exports.LanguageNotSupportedException = LanguageNotSupportedException;
-exports.LexiconFilterSensitiveLog = LexiconFilterSensitiveLog;
-exports.LexiconNotFoundException = LexiconNotFoundException;
-exports.LexiconSizeExceededException = LexiconSizeExceededException;
+exports.LanguageNotSupportedException = LanguageNotSupportedException$1;
+exports.LexiconNotFoundException = LexiconNotFoundException$1;
+exports.LexiconSizeExceededException = LexiconSizeExceededException$1;
 exports.ListLexiconsCommand = ListLexiconsCommand;
 exports.ListSpeechSynthesisTasksCommand = ListSpeechSynthesisTasksCommand;
-exports.MarksNotSupportedForFormatException = MarksNotSupportedForFormatException;
-exports.MaxLexemeLengthExceededException = MaxLexemeLengthExceededException;
-exports.MaxLexiconsNumberExceededException = MaxLexiconsNumberExceededException;
+exports.MarksNotSupportedForFormatException = MarksNotSupportedForFormatException$1;
+exports.MaxLexemeLengthExceededException = MaxLexemeLengthExceededException$1;
+exports.MaxLexiconsNumberExceededException = MaxLexiconsNumberExceededException$1;
 exports.OutputFormat = OutputFormat;
 exports.Polly = Polly;
 exports.PollyClient = PollyClient;
-exports.PollyServiceException = PollyServiceException;
+exports.PollyServiceException = PollyServiceException$1;
 exports.PutLexiconCommand = PutLexiconCommand;
-exports.PutLexiconInputFilterSensitiveLog = PutLexiconInputFilterSensitiveLog;
-exports.ServiceFailureException = ServiceFailureException;
+exports.ServiceFailureException = ServiceFailureException$1;
 exports.SpeechMarkType = SpeechMarkType;
-exports.SsmlMarksNotSupportedForTextTypeException = SsmlMarksNotSupportedForTextTypeException;
+exports.SsmlMarksNotSupportedForTextTypeException = SsmlMarksNotSupportedForTextTypeException$1;
 exports.StartSpeechSynthesisTaskCommand = StartSpeechSynthesisTaskCommand;
-exports.SynthesisTaskNotFoundException = SynthesisTaskNotFoundException;
+exports.SynthesisTaskNotFoundException = SynthesisTaskNotFoundException$1;
 exports.SynthesizeSpeechCommand = SynthesizeSpeechCommand;
-exports.SynthesizeSpeechOutputFilterSensitiveLog = SynthesizeSpeechOutputFilterSensitiveLog;
 exports.TaskStatus = TaskStatus;
-exports.TextLengthExceededException = TextLengthExceededException;
+exports.TextLengthExceededException = TextLengthExceededException$1;
 exports.TextType = TextType;
-exports.UnsupportedPlsAlphabetException = UnsupportedPlsAlphabetException;
-exports.UnsupportedPlsLanguageException = UnsupportedPlsLanguageException;
+exports.UnsupportedPlsAlphabetException = UnsupportedPlsAlphabetException$1;
+exports.UnsupportedPlsLanguageException = UnsupportedPlsLanguageException$1;
 exports.VoiceId = VoiceId;
 exports.paginateListSpeechSynthesisTasks = paginateListSpeechSynthesisTasks;