@aws-sdk/client-transcribe-streaming 3.928.0 → 3.929.0

package/dist-cjs/index.js

@@ -8,6 +8,7 @@ var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var middlewareWebsocket = require('@aws-sdk/middleware-websocket');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var eventstreamSerdeConfigResolver = require('@smithy/eventstream-serde-config-resolver');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
@@ -17,8 +18,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');
 var middlewareSdkTranscribeStreaming = require('@aws-sdk/middleware-sdk-transcribe-streaming');
 
 const resolveClientEndpointParameters = (options) => {
@@ -98,6 +97,7 @@ class TranscribeStreamingClient extends smithyClient.Client {
         const _config_10 = middlewareWebsocket.resolveWebSocketConfig(_config_9);
         const _config_11 = resolveRuntimeExtensions(_config_10, configuration?.extensions || []);
         this.config = _config_11;
+        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));
@@ -117,12 +117,12 @@ class TranscribeStreamingClient extends smithyClient.Client {
     }
 }
 
-class TranscribeStreamingServiceException extends smithyClient.ServiceException {
+let TranscribeStreamingServiceException$1 = class TranscribeStreamingServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, TranscribeStreamingServiceException.prototype);
     }
-}
+};
 
 const ItemType = {
     PRONUNCIATION: "pronunciation",
@@ -146,7 +146,7 @@ exports.AudioStream = void 0;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(exports.AudioStream || (exports.AudioStream = {}));
-class BadRequestException extends TranscribeStreamingServiceException {
+let BadRequestException$1 = class BadRequestException extends TranscribeStreamingServiceException$1 {
     name = "BadRequestException";
     $fault = "client";
     Message;
@@ -159,7 +159,7 @@ class BadRequestException extends TranscribeStreamingServiceException {
         Object.setPrototypeOf(this, BadRequestException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const CallAnalyticsLanguageCode = {
     DE_DE: "de-DE",
     EN_AU: "en-AU",
@@ -171,7 +171,7 @@ const CallAnalyticsLanguageCode = {
     IT_IT: "it-IT",
     PT_BR: "pt-BR",
 };
-class ConflictException extends TranscribeStreamingServiceException {
+let ConflictException$1 = class ConflictException extends TranscribeStreamingServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     Message;
@@ -184,8 +184,8 @@ class ConflictException extends TranscribeStreamingServiceException {
         Object.setPrototypeOf(this, ConflictException.prototype);
         this.Message = opts.Message;
     }
-}
-class InternalFailureException extends TranscribeStreamingServiceException {
+};
+let InternalFailureException$1 = class InternalFailureException extends TranscribeStreamingServiceException$1 {
     name = "InternalFailureException";
     $fault = "server";
     Message;
@@ -198,8 +198,8 @@ class InternalFailureException extends TranscribeStreamingServiceException {
         Object.setPrototypeOf(this, InternalFailureException.prototype);
         this.Message = opts.Message;
     }
-}
-class LimitExceededException extends TranscribeStreamingServiceException {
+};
+let LimitExceededException$1 = class LimitExceededException extends TranscribeStreamingServiceException$1 {
     name = "LimitExceededException";
     $fault = "client";
     Message;
@@ -212,8 +212,8 @@ class LimitExceededException extends TranscribeStreamingServiceException {
         Object.setPrototypeOf(this, LimitExceededException.prototype);
         this.Message = opts.Message;
     }
-}
-class ServiceUnavailableException extends TranscribeStreamingServiceException {
+};
+let ServiceUnavailableException$1 = class ServiceUnavailableException extends TranscribeStreamingServiceException$1 {
     name = "ServiceUnavailableException";
     $fault = "server";
     Message;
@@ -226,7 +226,7 @@ class ServiceUnavailableException extends TranscribeStreamingServiceException {
         Object.setPrototypeOf(this, ServiceUnavailableException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const Sentiment = {
     MIXED: "MIXED",
     NEGATIVE: "NEGATIVE",
@@ -296,7 +296,7 @@ const MedicalScribeVocabularyFilterMethod = {
     REMOVE: "remove",
     TAG: "tag",
 };
-class ResourceNotFoundException extends TranscribeStreamingServiceException {
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends TranscribeStreamingServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     Message;
@@ -309,7 +309,7 @@ class ResourceNotFoundException extends TranscribeStreamingServiceException {
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const LanguageCode = {
     AF_ZA: "af-ZA",
     AR_AE: "ar-AE",
@@ -374,7 +374,7 @@ const MediaEncoding = {
 const MedicalContentIdentificationType = {
     PHI: "PHI",
 };
-const Pronouns = {
+const Pronouns$1 = {
     HE_HIM: "HE_HIM",
     SHE_HER: "SHE_HER",
     THEY_THEM: "THEY_THEM",
@@ -474,1094 +474,183 @@ exports.TranscriptResultStream = void 0;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(exports.TranscriptResultStream || (exports.TranscriptResultStream = {}));
-const AudioStreamFilterSensitiveLog = (obj) => {
-    if (obj.AudioEvent !== undefined)
-        return { AudioEvent: obj.AudioEvent };
-    if (obj.ConfigurationEvent !== undefined)
-        return { ConfigurationEvent: obj.ConfigurationEvent };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const CallAnalyticsTranscriptResultStreamFilterSensitiveLog = (obj) => {
-    if (obj.UtteranceEvent !== undefined)
-        return { UtteranceEvent: obj.UtteranceEvent };
-    if (obj.CategoryEvent !== undefined)
-        return { CategoryEvent: obj.CategoryEvent };
-    if (obj.BadRequestException !== undefined)
-        return { BadRequestException: obj.BadRequestException };
-    if (obj.LimitExceededException !== undefined)
-        return { LimitExceededException: obj.LimitExceededException };
-    if (obj.InternalFailureException !== undefined)
-        return { InternalFailureException: obj.InternalFailureException };
-    if (obj.ConflictException !== undefined)
-        return { ConflictException: obj.ConflictException };
-    if (obj.ServiceUnavailableException !== undefined)
-        return { ServiceUnavailableException: obj.ServiceUnavailableException };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const MedicalScribePatientContextFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Pronouns && { Pronouns: smithyClient.SENSITIVE_STRING }),
-});
-const MedicalScribeContextFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PatientContext && { PatientContext: MedicalScribePatientContextFilterSensitiveLog(obj.PatientContext) }),
-});
-const MedicalScribeConfigurationEventFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.MedicalScribeContext && {
-        MedicalScribeContext: MedicalScribeContextFilterSensitiveLog(obj.MedicalScribeContext),
-    }),
-});
-const MedicalScribeInputStreamFilterSensitiveLog = (obj) => {
-    if (obj.AudioEvent !== undefined)
-        return { AudioEvent: obj.AudioEvent };
-    if (obj.SessionControlEvent !== undefined)
-        return { SessionControlEvent: obj.SessionControlEvent };
-    if (obj.ConfigurationEvent !== undefined)
-        return { ConfigurationEvent: MedicalScribeConfigurationEventFilterSensitiveLog(obj.ConfigurationEvent) };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const MedicalScribeResultStreamFilterSensitiveLog = (obj) => {
-    if (obj.TranscriptEvent !== undefined)
-        return { TranscriptEvent: obj.TranscriptEvent };
-    if (obj.BadRequestException !== undefined)
-        return { BadRequestException: obj.BadRequestException };
-    if (obj.LimitExceededException !== undefined)
-        return { LimitExceededException: obj.LimitExceededException };
-    if (obj.InternalFailureException !== undefined)
-        return { InternalFailureException: obj.InternalFailureException };
-    if (obj.ConflictException !== undefined)
-        return { ConflictException: obj.ConflictException };
-    if (obj.ServiceUnavailableException !== undefined)
-        return { ServiceUnavailableException: obj.ServiceUnavailableException };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const MedicalTranscriptResultStreamFilterSensitiveLog = (obj) => {
-    if (obj.TranscriptEvent !== undefined)
-        return { TranscriptEvent: obj.TranscriptEvent };
-    if (obj.BadRequestException !== undefined)
-        return { BadRequestException: obj.BadRequestException };
-    if (obj.LimitExceededException !== undefined)
-        return { LimitExceededException: obj.LimitExceededException };
-    if (obj.InternalFailureException !== undefined)
-        return { InternalFailureException: obj.InternalFailureException };
-    if (obj.ConflictException !== undefined)
-        return { ConflictException: obj.ConflictException };
-    if (obj.ServiceUnavailableException !== undefined)
-        return { ServiceUnavailableException: obj.ServiceUnavailableException };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.AudioStream && { AudioStream: "STREAMING_CONTENT" }),
-});
-const StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.CallAnalyticsTranscriptResultStream && { CallAnalyticsTranscriptResultStream: "STREAMING_CONTENT" }),
-});
-const StartMedicalScribeStreamRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.InputStream && { InputStream: "STREAMING_CONTENT" }),
-});
-const StartMedicalScribeStreamResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ResultStream && { ResultStream: "STREAMING_CONTENT" }),
-});
-const StartMedicalStreamTranscriptionRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.AudioStream && { AudioStream: "STREAMING_CONTENT" }),
-});
-const StartMedicalStreamTranscriptionResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.TranscriptResultStream && { TranscriptResultStream: "STREAMING_CONTENT" }),
-});
-const StartStreamTranscriptionRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.AudioStream && { AudioStream: "STREAMING_CONTENT" }),
-});
-const TranscriptResultStreamFilterSensitiveLog = (obj) => {
-    if (obj.TranscriptEvent !== undefined)
-        return { TranscriptEvent: obj.TranscriptEvent };
-    if (obj.BadRequestException !== undefined)
-        return { BadRequestException: obj.BadRequestException };
-    if (obj.LimitExceededException !== undefined)
-        return { LimitExceededException: obj.LimitExceededException };
-    if (obj.InternalFailureException !== undefined)
-        return { InternalFailureException: obj.InternalFailureException };
-    if (obj.ConflictException !== undefined)
-        return { ConflictException: obj.ConflictException };
-    if (obj.ServiceUnavailableException !== undefined)
-        return { ServiceUnavailableException: obj.ServiceUnavailableException };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const StartStreamTranscriptionResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.TranscriptResultStream && { TranscriptResultStream: "STREAMING_CONTENT" }),
-});
 
-const se_GetMedicalScribeStreamCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/medical-scribe-stream/{SessionId}");
-    b.p("SessionId", () => input.SessionId, "{SessionId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_StartCallAnalyticsStreamTranscriptionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
-        "content-type": "application/json",
-        [_xatlc]: input[_LC],
-        [_xatsr]: [() => smithyClient.isSerializableHeaderValue(input[_MSRH]), () => input[_MSRH].toString()],
-        [_xatme]: input[_ME],
-        [_xatvn]: input[_VN],
-        [_xatsi]: input[_SI],
-        [_xatvfn]: input[_VFN],
-        [_xatvfm]: input[_VFM],
-        [_xatlmn]: input[_LMN],
-        [_xatil]: [() => smithyClient.isSerializableHeaderValue(input[_IL]), () => input[_IL].toString()],
-        [_xatlo]: input[_LO],
-        [_xatpl]: input[_PL],
-        [_xatvn_]: input[_VNo],
-        [_xatvfn_]: input[_VFNo],
-        [_xateprs]: [() => smithyClient.isSerializableHeaderValue(input[_EPRS]), () => input[_EPRS].toString()],
-        [_xatprs]: input[_PRS],
-        [_xatcit]: input[_CIT],
-        [_xatcrt]: input[_CRT],
-        [_xatpet]: input[_PET],
-    });
-    b.bp("/call-analytics-stream-transcription");
-    let body;
-    if (input.AudioStream !== undefined) {
-        body = se_AudioStream(input.AudioStream, context);
-    }
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartMedicalScribeStreamCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
-        "content-type": "application/json",
-        [_xatsi]: input[_SI],
-        [_xatlc]: input[_LC],
-        [_xatsr]: [() => smithyClient.isSerializableHeaderValue(input[_MSRH]), () => input[_MSRH].toString()],
-        [_xatme]: input[_ME],
-    });
-    b.bp("/medical-scribe-stream");
-    let body;
-    if (input.InputStream !== undefined) {
-        body = se_MedicalScribeInputStream(input.InputStream, context);
-    }
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartMedicalStreamTranscriptionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
-        "content-type": "application/json",
-        [_xatlc]: input[_LC],
-        [_xatsr]: [() => smithyClient.isSerializableHeaderValue(input[_MSRH]), () => input[_MSRH].toString()],
-        [_xatme]: input[_ME],
-        [_xatvn]: input[_VN],
-        [_xats]: input[_S],
-        [_xatt]: input[_T],
-        [_xatssl]: [() => smithyClient.isSerializableHeaderValue(input[_SSL]), () => input[_SSL].toString()],
-        [_xatsi]: input[_SI],
-        [_xateci]: [() => smithyClient.isSerializableHeaderValue(input[_ECI]), () => input[_ECI].toString()],
-        [_xatnoc]: [() => smithyClient.isSerializableHeaderValue(input[_NOC]), () => input[_NOC].toString()],
-        [_xatcit]: input[_CIT],
-    });
-    b.bp("/medical-stream-transcription");
-    let body;
-    if (input.AudioStream !== undefined) {
-        body = se_AudioStream(input.AudioStream, context);
-    }
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartStreamTranscriptionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
-        "content-type": "application/json",
-        [_xatlc]: input[_LC],
-        [_xatsr]: [() => smithyClient.isSerializableHeaderValue(input[_MSRH]), () => input[_MSRH].toString()],
-        [_xatme]: input[_ME],
-        [_xatvn]: input[_VN],
-        [_xatsi]: input[_SI],
-        [_xatvfn]: input[_VFN],
-        [_xatvfm]: input[_VFM],
-        [_xatssl]: [() => smithyClient.isSerializableHeaderValue(input[_SSL]), () => input[_SSL].toString()],
-        [_xateci]: [() => smithyClient.isSerializableHeaderValue(input[_ECI]), () => input[_ECI].toString()],
-        [_xatnoc]: [() => smithyClient.isSerializableHeaderValue(input[_NOC]), () => input[_NOC].toString()],
-        [_xateprs]: [() => smithyClient.isSerializableHeaderValue(input[_EPRS]), () => input[_EPRS].toString()],
-        [_xatprs]: input[_PRS],
-        [_xatcit]: input[_CIT],
-        [_xatcrt]: input[_CRT],
-        [_xatpet]: input[_PET],
-        [_xatlmn]: input[_LMN],
-        [_xatil]: [() => smithyClient.isSerializableHeaderValue(input[_IL]), () => input[_IL].toString()],
-        [_xatlo]: input[_LO],
-        [_xatpl]: input[_PL],
-        [_xatiml]: [() => smithyClient.isSerializableHeaderValue(input[_IML]), () => input[_IML].toString()],
-        [_xatvn_]: input[_VNo],
-        [_xatvfn_]: input[_VFNo],
-    });
-    b.bp("/stream-transcription");
-    let body;
-    if (input.AudioStream !== undefined) {
-        body = se_AudioStream(input.AudioStream, context);
-    }
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_GetMedicalScribeStreamCommand = 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, {
-        MedicalScribeStreamDetails: (_) => de_MedicalScribeStreamDetails(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartCallAnalyticsStreamTranscriptionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_RI]: [, output.headers[_xari]],
-        [_LC]: [, output.headers[_xatlc]],
-        [_MSRH]: [() => void 0 !== output.headers[_xatsr], () => smithyClient.strictParseInt32(output.headers[_xatsr])],
-        [_ME]: [, output.headers[_xatme]],
-        [_VN]: [, output.headers[_xatvn]],
-        [_SI]: [, output.headers[_xatsi]],
-        [_VFN]: [, output.headers[_xatvfn]],
-        [_VFM]: [, output.headers[_xatvfm]],
-        [_LMN]: [, output.headers[_xatlmn]],
-        [_IL]: [() => void 0 !== output.headers[_xatil], () => smithyClient.parseBoolean(output.headers[_xatil])],
-        [_LO]: [, output.headers[_xatlo]],
-        [_PL]: [, output.headers[_xatpl]],
-        [_VNo]: [, output.headers[_xatvn_]],
-        [_VFNo]: [, output.headers[_xatvfn_]],
-        [_EPRS]: [() => void 0 !== output.headers[_xateprs], () => smithyClient.parseBoolean(output.headers[_xateprs])],
-        [_PRS]: [, output.headers[_xatprs]],
-        [_CIT]: [, output.headers[_xatcit]],
-        [_CRT]: [, output.headers[_xatcrt]],
-        [_PET]: [, output.headers[_xatpet]],
-    });
-    const data = output.body;
-    contents.CallAnalyticsTranscriptResultStream = de_CallAnalyticsTranscriptResultStream(data, context);
-    return contents;
-};
-const de_StartMedicalScribeStreamCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_SI]: [, output.headers[_xatsi]],
-        [_RI]: [, output.headers[_xari]],
-        [_LC]: [, output.headers[_xatlc]],
-        [_MSRH]: [() => void 0 !== output.headers[_xatsr], () => smithyClient.strictParseInt32(output.headers[_xatsr])],
-        [_ME]: [, output.headers[_xatme]],
-    });
-    const data = output.body;
-    contents.ResultStream = de_MedicalScribeResultStream(data, context);
-    return contents;
-};
-const de_StartMedicalStreamTranscriptionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_RI]: [, output.headers[_xari]],
-        [_LC]: [, output.headers[_xatlc]],
-        [_MSRH]: [() => void 0 !== output.headers[_xatsr], () => smithyClient.strictParseInt32(output.headers[_xatsr])],
-        [_ME]: [, output.headers[_xatme]],
-        [_VN]: [, output.headers[_xatvn]],
-        [_S]: [, output.headers[_xats]],
-        [_T]: [, output.headers[_xatt]],
-        [_SSL]: [() => void 0 !== output.headers[_xatssl], () => smithyClient.parseBoolean(output.headers[_xatssl])],
-        [_SI]: [, output.headers[_xatsi]],
-        [_ECI]: [() => void 0 !== output.headers[_xateci], () => smithyClient.parseBoolean(output.headers[_xateci])],
-        [_NOC]: [() => void 0 !== output.headers[_xatnoc], () => smithyClient.strictParseInt32(output.headers[_xatnoc])],
-        [_CIT]: [, output.headers[_xatcit]],
-    });
-    const data = output.body;
-    contents.TranscriptResultStream = de_MedicalTranscriptResultStream(data, context);
-    return contents;
-};
-const de_StartStreamTranscriptionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_RI]: [, output.headers[_xari]],
-        [_LC]: [, output.headers[_xatlc]],
-        [_MSRH]: [() => void 0 !== output.headers[_xatsr], () => smithyClient.strictParseInt32(output.headers[_xatsr])],
-        [_ME]: [, output.headers[_xatme]],
-        [_VN]: [, output.headers[_xatvn]],
-        [_SI]: [, output.headers[_xatsi]],
-        [_VFN]: [, output.headers[_xatvfn]],
-        [_VFM]: [, output.headers[_xatvfm]],
-        [_SSL]: [() => void 0 !== output.headers[_xatssl], () => smithyClient.parseBoolean(output.headers[_xatssl])],
-        [_ECI]: [() => void 0 !== output.headers[_xateci], () => smithyClient.parseBoolean(output.headers[_xateci])],
-        [_NOC]: [() => void 0 !== output.headers[_xatnoc], () => smithyClient.strictParseInt32(output.headers[_xatnoc])],
-        [_EPRS]: [() => void 0 !== output.headers[_xateprs], () => smithyClient.parseBoolean(output.headers[_xateprs])],
-        [_PRS]: [, output.headers[_xatprs]],
-        [_CIT]: [, output.headers[_xatcit]],
-        [_CRT]: [, output.headers[_xatcrt]],
-        [_PET]: [, output.headers[_xatpet]],
-        [_LMN]: [, output.headers[_xatlmn]],
-        [_IL]: [() => void 0 !== output.headers[_xatil], () => smithyClient.parseBoolean(output.headers[_xatil])],
-        [_LO]: [, output.headers[_xatlo]],
-        [_PL]: [, output.headers[_xatpl]],
-        [_IML]: [() => void 0 !== output.headers[_xatiml], () => smithyClient.parseBoolean(output.headers[_xatiml])],
-        [_VNo]: [, output.headers[_xatvn_]],
-        [_VFNo]: [, output.headers[_xatvfn_]],
-    });
-    const data = output.body;
-    contents.TranscriptResultStream = de_TranscriptResultStream(data, context);
-    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 "BadRequestException":
-        case "com.amazonaws.transcribestreaming#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput);
-        case "InternalFailureException":
-        case "com.amazonaws.transcribestreaming#InternalFailureException":
-            throw await de_InternalFailureExceptionRes(parsedOutput);
-        case "LimitExceededException":
-        case "com.amazonaws.transcribestreaming#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.transcribestreaming#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.transcribestreaming#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.transcribestreaming#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(TranscribeStreamingServiceException);
-const de_BadRequestExceptionRes = 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 BadRequestException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConflictExceptionRes = 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 ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalFailureExceptionRes = 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 InternalFailureException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_LimitExceededExceptionRes = 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 LimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = 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 ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceUnavailableExceptionRes = 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 ServiceUnavailableException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_AudioStream = (input, context) => {
-    const eventMarshallingVisitor = (event) => exports.AudioStream.visit(event, {
-        AudioEvent: (value) => se_AudioEvent_event(value),
-        ConfigurationEvent: (value) => se_ConfigurationEvent_event(value, context),
-        _: (value) => value,
-    });
-    return context.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
-};
-const se_MedicalScribeInputStream = (input, context) => {
-    const eventMarshallingVisitor = (event) => exports.MedicalScribeInputStream.visit(event, {
-        AudioEvent: (value) => se_MedicalScribeAudioEvent_event(value),
-        SessionControlEvent: (value) => se_MedicalScribeSessionControlEvent_event(value, context),
-        ConfigurationEvent: (value) => se_MedicalScribeConfigurationEvent_event(value, context),
-        _: (value) => value,
-    });
-    return context.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
-};
-const se_AudioEvent_event = (input, context) => {
-    const headers = {
-        ":event-type": { type: "string", value: "AudioEvent" },
-        ":message-type": { type: "string", value: "event" },
-        ":content-type": { type: "string", value: "application/octet-stream" },
-    };
-    let body = new Uint8Array();
-    if (input.AudioChunk != null) {
-        body = input.AudioChunk;
-    }
-    return { headers, body };
-};
-const se_ConfigurationEvent_event = (input, context) => {
-    const headers = {
-        ":event-type": { type: "string", value: "ConfigurationEvent" },
-        ":message-type": { type: "string", value: "event" },
-        ":content-type": { type: "string", value: "application/json" },
-    };
-    let body = new Uint8Array();
-    body = smithyClient._json(input);
-    body = context.utf8Decoder(JSON.stringify(body));
-    return { headers, body };
-};
-const se_MedicalScribeAudioEvent_event = (input, context) => {
-    const headers = {
-        ":event-type": { type: "string", value: "AudioEvent" },
-        ":message-type": { type: "string", value: "event" },
-        ":content-type": { type: "string", value: "application/octet-stream" },
-    };
-    let body = new Uint8Array();
-    if (input.AudioChunk != null) {
-        body = input.AudioChunk;
-    }
-    return { headers, body };
-};
-const se_MedicalScribeConfigurationEvent_event = (input, context) => {
-    const headers = {
-        ":event-type": { type: "string", value: "ConfigurationEvent" },
-        ":message-type": { type: "string", value: "event" },
-        ":content-type": { type: "string", value: "application/json" },
-    };
-    let body = new Uint8Array();
-    body = smithyClient._json(input);
-    body = context.utf8Decoder(JSON.stringify(body));
-    return { headers, body };
-};
-const se_MedicalScribeSessionControlEvent_event = (input, context) => {
-    const headers = {
-        ":event-type": { type: "string", value: "SessionControlEvent" },
-        ":message-type": { type: "string", value: "event" },
-        ":content-type": { type: "string", value: "application/json" },
-    };
-    let body = new Uint8Array();
-    body = smithyClient._json(input);
-    body = context.utf8Decoder(JSON.stringify(body));
-    return { headers, body };
-};
-const de_CallAnalyticsTranscriptResultStream = (output, context) => {
-    return context.eventStreamMarshaller.deserialize(output, async (event) => {
-        if (event["UtteranceEvent"] != null) {
-            return {
-                UtteranceEvent: await de_UtteranceEvent_event(event["UtteranceEvent"], context),
-            };
-        }
-        if (event["CategoryEvent"] != null) {
-            return {
-                CategoryEvent: await de_CategoryEvent_event(event["CategoryEvent"], context),
-            };
-        }
-        if (event["BadRequestException"] != null) {
-            return {
-                BadRequestException: await de_BadRequestException_event(event["BadRequestException"], context),
-            };
-        }
-        if (event["LimitExceededException"] != null) {
-            return {
-                LimitExceededException: await de_LimitExceededException_event(event["LimitExceededException"], context),
-            };
-        }
-        if (event["InternalFailureException"] != null) {
-            return {
-                InternalFailureException: await de_InternalFailureException_event(event["InternalFailureException"], context),
-            };
-        }
-        if (event["ConflictException"] != null) {
-            return {
-                ConflictException: await de_ConflictException_event(event["ConflictException"], context),
-            };
-        }
-        if (event["ServiceUnavailableException"] != null) {
-            return {
-                ServiceUnavailableException: await de_ServiceUnavailableException_event(event["ServiceUnavailableException"], context),
-            };
-        }
-        return { $unknown: event };
-    });
-};
-const de_MedicalScribeResultStream = (output, context) => {
-    return context.eventStreamMarshaller.deserialize(output, async (event) => {
-        if (event["TranscriptEvent"] != null) {
-            return {
-                TranscriptEvent: await de_MedicalScribeTranscriptEvent_event(event["TranscriptEvent"], context),
-            };
-        }
-        if (event["BadRequestException"] != null) {
-            return {
-                BadRequestException: await de_BadRequestException_event(event["BadRequestException"], context),
-            };
-        }
-        if (event["LimitExceededException"] != null) {
-            return {
-                LimitExceededException: await de_LimitExceededException_event(event["LimitExceededException"], context),
-            };
-        }
-        if (event["InternalFailureException"] != null) {
-            return {
-                InternalFailureException: await de_InternalFailureException_event(event["InternalFailureException"], context),
-            };
-        }
-        if (event["ConflictException"] != null) {
-            return {
-                ConflictException: await de_ConflictException_event(event["ConflictException"], context),
-            };
-        }
-        if (event["ServiceUnavailableException"] != null) {
-            return {
-                ServiceUnavailableException: await de_ServiceUnavailableException_event(event["ServiceUnavailableException"], context),
-            };
-        }
-        return { $unknown: event };
-    });
-};
-const de_MedicalTranscriptResultStream = (output, context) => {
-    return context.eventStreamMarshaller.deserialize(output, async (event) => {
-        if (event["TranscriptEvent"] != null) {
-            return {
-                TranscriptEvent: await de_MedicalTranscriptEvent_event(event["TranscriptEvent"], context),
-            };
-        }
-        if (event["BadRequestException"] != null) {
-            return {
-                BadRequestException: await de_BadRequestException_event(event["BadRequestException"], context),
-            };
-        }
-        if (event["LimitExceededException"] != null) {
-            return {
-                LimitExceededException: await de_LimitExceededException_event(event["LimitExceededException"], context),
-            };
-        }
-        if (event["InternalFailureException"] != null) {
-            return {
-                InternalFailureException: await de_InternalFailureException_event(event["InternalFailureException"], context),
-            };
-        }
-        if (event["ConflictException"] != null) {
-            return {
-                ConflictException: await de_ConflictException_event(event["ConflictException"], context),
-            };
-        }
-        if (event["ServiceUnavailableException"] != null) {
-            return {
-                ServiceUnavailableException: await de_ServiceUnavailableException_event(event["ServiceUnavailableException"], context),
-            };
-        }
-        return { $unknown: event };
-    });
-};
-const de_TranscriptResultStream = (output, context) => {
-    return context.eventStreamMarshaller.deserialize(output, async (event) => {
-        if (event["TranscriptEvent"] != null) {
-            return {
-                TranscriptEvent: await de_TranscriptEvent_event(event["TranscriptEvent"], context),
-            };
-        }
-        if (event["BadRequestException"] != null) {
-            return {
-                BadRequestException: await de_BadRequestException_event(event["BadRequestException"], context),
-            };
-        }
-        if (event["LimitExceededException"] != null) {
-            return {
-                LimitExceededException: await de_LimitExceededException_event(event["LimitExceededException"], context),
-            };
-        }
-        if (event["InternalFailureException"] != null) {
-            return {
-                InternalFailureException: await de_InternalFailureException_event(event["InternalFailureException"], context),
-            };
-        }
-        if (event["ConflictException"] != null) {
-            return {
-                ConflictException: await de_ConflictException_event(event["ConflictException"], context),
-            };
-        }
-        if (event["ServiceUnavailableException"] != null) {
-            return {
-                ServiceUnavailableException: await de_ServiceUnavailableException_event(event["ServiceUnavailableException"], context),
-            };
-        }
-        return { $unknown: event };
-    });
-};
-const de_BadRequestException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_BadRequestExceptionRes(parsedOutput);
-};
-const de_CategoryEvent_event = async (output, context) => {
-    const contents = {};
-    const data = await core$1.parseJsonBody(output.body, context);
-    Object.assign(contents, smithyClient._json(data));
-    return contents;
-};
-const de_ConflictException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_ConflictExceptionRes(parsedOutput);
-};
-const de_InternalFailureException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_InternalFailureExceptionRes(parsedOutput);
-};
-const de_LimitExceededException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_LimitExceededExceptionRes(parsedOutput);
-};
-const de_MedicalScribeTranscriptEvent_event = async (output, context) => {
-    const contents = {};
-    const data = await core$1.parseJsonBody(output.body, context);
-    Object.assign(contents, de_MedicalScribeTranscriptEvent(data));
-    return contents;
-};
-const de_MedicalTranscriptEvent_event = async (output, context) => {
-    const contents = {};
-    const data = await core$1.parseJsonBody(output.body, context);
-    Object.assign(contents, de_MedicalTranscriptEvent(data));
-    return contents;
-};
-const de_ServiceUnavailableException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_ServiceUnavailableExceptionRes(parsedOutput);
-};
-const de_TranscriptEvent_event = async (output, context) => {
-    const contents = {};
-    const data = await core$1.parseJsonBody(output.body, context);
-    Object.assign(contents, de_TranscriptEvent(data));
-    return contents;
-};
-const de_UtteranceEvent_event = async (output, context) => {
-    const contents = {};
-    const data = await core$1.parseJsonBody(output.body, context);
-    Object.assign(contents, de_UtteranceEvent(data));
-    return contents;
-};
-const de_Alternative = (output, context) => {
-    return smithyClient.take(output, {
-        Entities: (_) => de_EntityList(_),
-        Items: (_) => de_ItemList(_),
-        Transcript: smithyClient.expectString,
-    });
-};
-const de_AlternativeList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Alternative(entry);
-    });
-    return retVal;
-};
-const de_CallAnalyticsEntity = (output, context) => {
-    return smithyClient.take(output, {
-        BeginOffsetMillis: smithyClient.expectLong,
-        Category: smithyClient.expectString,
-        Confidence: smithyClient.limitedParseDouble,
-        Content: smithyClient.expectString,
-        EndOffsetMillis: smithyClient.expectLong,
-        Type: smithyClient.expectString,
-    });
-};
-const de_CallAnalyticsEntityList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_CallAnalyticsEntity(entry);
-    });
-    return retVal;
-};
-const de_CallAnalyticsItem = (output, context) => {
-    return smithyClient.take(output, {
-        BeginOffsetMillis: smithyClient.expectLong,
-        Confidence: smithyClient.limitedParseDouble,
-        Content: smithyClient.expectString,
-        EndOffsetMillis: smithyClient.expectLong,
-        Stable: smithyClient.expectBoolean,
-        Type: smithyClient.expectString,
-        VocabularyFilterMatch: smithyClient.expectBoolean,
-    });
-};
-const de_CallAnalyticsItemList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_CallAnalyticsItem(entry);
-    });
-    return retVal;
-};
-const de_CallAnalyticsLanguageIdentification = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_CallAnalyticsLanguageWithScore(entry);
-    });
-    return retVal;
-};
-const de_CallAnalyticsLanguageWithScore = (output, context) => {
-    return smithyClient.take(output, {
-        LanguageCode: smithyClient.expectString,
-        Score: smithyClient.limitedParseDouble,
-    });
-};
-const de_Entity = (output, context) => {
-    return smithyClient.take(output, {
-        Category: smithyClient.expectString,
-        Confidence: smithyClient.limitedParseDouble,
-        Content: smithyClient.expectString,
-        EndTime: smithyClient.limitedParseDouble,
-        StartTime: smithyClient.limitedParseDouble,
-        Type: smithyClient.expectString,
-    });
-};
-const de_EntityList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Entity(entry);
-    });
-    return retVal;
-};
-const de_Item = (output, context) => {
-    return smithyClient.take(output, {
-        Confidence: smithyClient.limitedParseDouble,
-        Content: smithyClient.expectString,
-        EndTime: smithyClient.limitedParseDouble,
-        Speaker: smithyClient.expectString,
-        Stable: smithyClient.expectBoolean,
-        StartTime: smithyClient.limitedParseDouble,
-        Type: smithyClient.expectString,
-        VocabularyFilterMatch: smithyClient.expectBoolean,
-    });
-};
-const de_ItemList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Item(entry);
-    });
-    return retVal;
-};
-const de_LanguageIdentification = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_LanguageWithScore(entry);
-    });
-    return retVal;
-};
-const de_LanguageWithScore = (output, context) => {
-    return smithyClient.take(output, {
-        LanguageCode: smithyClient.expectString,
-        Score: smithyClient.limitedParseDouble,
-    });
-};
-const de_MedicalAlternative = (output, context) => {
-    return smithyClient.take(output, {
-        Entities: (_) => de_MedicalEntityList(_),
-        Items: (_) => de_MedicalItemList(_),
-        Transcript: smithyClient.expectString,
-    });
-};
-const de_MedicalAlternativeList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_MedicalAlternative(entry);
-    });
-    return retVal;
-};
-const de_MedicalEntity = (output, context) => {
-    return smithyClient.take(output, {
-        Category: smithyClient.expectString,
-        Confidence: smithyClient.limitedParseDouble,
-        Content: smithyClient.expectString,
-        EndTime: smithyClient.limitedParseDouble,
-        StartTime: smithyClient.limitedParseDouble,
-    });
-};
-const de_MedicalEntityList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_MedicalEntity(entry);
-    });
-    return retVal;
-};
-const de_MedicalItem = (output, context) => {
-    return smithyClient.take(output, {
-        Confidence: smithyClient.limitedParseDouble,
-        Content: smithyClient.expectString,
-        EndTime: smithyClient.limitedParseDouble,
-        Speaker: smithyClient.expectString,
-        StartTime: smithyClient.limitedParseDouble,
-        Type: smithyClient.expectString,
-    });
-};
-const de_MedicalItemList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_MedicalItem(entry);
-    });
-    return retVal;
-};
-const de_MedicalResult = (output, context) => {
-    return smithyClient.take(output, {
-        Alternatives: (_) => de_MedicalAlternativeList(_),
-        ChannelId: smithyClient.expectString,
-        EndTime: smithyClient.limitedParseDouble,
-        IsPartial: smithyClient.expectBoolean,
-        ResultId: smithyClient.expectString,
-        StartTime: smithyClient.limitedParseDouble,
-    });
-};
-const de_MedicalResultList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_MedicalResult(entry);
-    });
-    return retVal;
-};
-const de_MedicalScribeStreamDetails = (output, context) => {
-    return smithyClient.take(output, {
-        ChannelDefinitions: smithyClient._json,
-        EncryptionSettings: smithyClient._json,
-        LanguageCode: smithyClient.expectString,
-        MediaEncoding: smithyClient.expectString,
-        MediaSampleRateHertz: smithyClient.expectInt32,
-        MedicalScribeContextProvided: smithyClient.expectBoolean,
-        PostStreamAnalyticsResult: smithyClient._json,
-        PostStreamAnalyticsSettings: smithyClient._json,
-        ResourceAccessRoleArn: smithyClient.expectString,
-        SessionId: smithyClient.expectString,
-        StreamCreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        StreamEndedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        StreamStatus: smithyClient.expectString,
-        VocabularyFilterMethod: smithyClient.expectString,
-        VocabularyFilterName: smithyClient.expectString,
-        VocabularyName: smithyClient.expectString,
-    });
-};
-const de_MedicalScribeTranscriptEvent = (output, context) => {
-    return smithyClient.take(output, {
-        TranscriptSegment: (_) => de_MedicalScribeTranscriptSegment(_),
-    });
-};
-const de_MedicalScribeTranscriptItem = (output, context) => {
-    return smithyClient.take(output, {
-        BeginAudioTime: smithyClient.limitedParseDouble,
-        Confidence: smithyClient.limitedParseDouble,
-        Content: smithyClient.expectString,
-        EndAudioTime: smithyClient.limitedParseDouble,
-        Type: smithyClient.expectString,
-        VocabularyFilterMatch: smithyClient.expectBoolean,
-    });
-};
-const de_MedicalScribeTranscriptItemList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_MedicalScribeTranscriptItem(entry);
-    });
-    return retVal;
-};
-const de_MedicalScribeTranscriptSegment = (output, context) => {
-    return smithyClient.take(output, {
-        BeginAudioTime: smithyClient.limitedParseDouble,
-        ChannelId: smithyClient.expectString,
-        Content: smithyClient.expectString,
-        EndAudioTime: smithyClient.limitedParseDouble,
-        IsPartial: smithyClient.expectBoolean,
-        Items: (_) => de_MedicalScribeTranscriptItemList(_),
-        SegmentId: smithyClient.expectString,
-    });
-};
-const de_MedicalTranscript = (output, context) => {
-    return smithyClient.take(output, {
-        Results: (_) => de_MedicalResultList(_),
-    });
-};
-const de_MedicalTranscriptEvent = (output, context) => {
-    return smithyClient.take(output, {
-        Transcript: (_) => de_MedicalTranscript(_),
-    });
-};
-const de_Result = (output, context) => {
-    return smithyClient.take(output, {
-        Alternatives: (_) => de_AlternativeList(_),
-        ChannelId: smithyClient.expectString,
-        EndTime: smithyClient.limitedParseDouble,
-        IsPartial: smithyClient.expectBoolean,
-        LanguageCode: smithyClient.expectString,
-        LanguageIdentification: (_) => de_LanguageIdentification(_),
-        ResultId: smithyClient.expectString,
-        StartTime: smithyClient.limitedParseDouble,
-    });
-};
-const de_ResultList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Result(entry);
-    });
-    return retVal;
-};
-const de_Transcript = (output, context) => {
-    return smithyClient.take(output, {
-        Results: (_) => de_ResultList(_),
-    });
-};
-const de_TranscriptEvent = (output, context) => {
-    return smithyClient.take(output, {
-        Transcript: (_) => de_Transcript(_),
-    });
-};
-const de_UtteranceEvent = (output, context) => {
-    return smithyClient.take(output, {
-        BeginOffsetMillis: smithyClient.expectLong,
-        EndOffsetMillis: smithyClient.expectLong,
-        Entities: (_) => de_CallAnalyticsEntityList(_),
-        IsPartial: smithyClient.expectBoolean,
-        IssuesDetected: smithyClient._json,
-        Items: (_) => de_CallAnalyticsItemList(_),
-        LanguageCode: smithyClient.expectString,
-        LanguageIdentification: (_) => de_CallAnalyticsLanguageIdentification(_),
-        ParticipantRole: smithyClient.expectString,
-        Sentiment: smithyClient.expectString,
-        Transcript: smithyClient.expectString,
-        UtteranceId: smithyClient.expectString,
-    });
-};
-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 _A = "Alternative";
+const _AC = "AudioChunk";
+const _AE = "AudioEvent";
+const _AL = "AlternativeList";
+const _AS = "AudioStream";
+const _Al = "Alternatives";
+const _B = "Begin";
+const _BAT = "BeginAudioTime";
+const _BOM = "BeginOffsetMillis";
+const _BRE = "BadRequestException";
+const _C = "Category";
+const _CAE = "CallAnalyticsEntity";
+const _CAEL = "CallAnalyticsEntityList";
+const _CAI = "CallAnalyticsItem";
+const _CAIL = "CallAnalyticsItemList";
+const _CALI = "CallAnalyticsLanguageIdentification";
+const _CALWS = "CallAnalyticsLanguageWithScore";
+const _CATRS = "CallAnalyticsTranscriptResultStream";
+const _CD = "ChannelDefinition";
+const _CDh = "ChannelDefinitions";
+const _CE = "CategoryEvent";
+const _CEo = "ConfigurationEvent";
+const _CEon = "ConflictException";
+const _CI = "ChannelId";
 const _CIT = "ContentIdentificationType";
+const _CNGR = "ClinicalNoteGenerationResult";
+const _CNGS = "ClinicalNoteGenerationSettings";
+const _CNOL = "ClinicalNoteOutputLocation";
+const _CO = "CharacterOffsets";
+const _CRO = "ContentRedactionOutput";
 const _CRT = "ContentRedactionType";
+const _Co = "Content";
+const _Con = "Confidence";
+const _DARA = "DataAccessRoleArn";
+const _E = "Entities";
+const _EAT = "EndAudioTime";
 const _ECI = "EnableChannelIdentification";
+const _EL = "EntityList";
+const _EOM = "EndOffsetMillis";
 const _EPRS = "EnablePartialResultsStabilization";
+const _ES = "EncryptionSettings";
+const _ET = "EndTime";
+const _En = "End";
+const _Ent = "Entity";
+const _FR = "FailureReason";
+const _GMSS = "GetMedicalScribeStream";
+const _GMSSR = "GetMedicalScribeStreamRequest";
+const _GMSSRe = "GetMedicalScribeStreamResponse";
+const _I = "Items";
+const _ID = "IssueDetected";
+const _IDs = "IssuesDetected";
+const _IFE = "InternalFailureException";
 const _IL = "IdentifyLanguage";
+const _ILt = "ItemList";
 const _IML = "IdentifyMultipleLanguages";
+const _IP = "IsPartial";
+const _IS = "InputStream";
+const _It = "Item";
+const _KEC = "KmsEncryptionContext";
+const _KKI = "KmsKeyId";
 const _LC = "LanguageCode";
+const _LEE = "LimitExceededException";
+const _LI = "LanguageIdentification";
 const _LMN = "LanguageModelName";
 const _LO = "LanguageOptions";
-const _ME = "MediaEncoding";
+const _LWS = "LanguageWithScore";
+const _M = "Message";
+const _MA = "MedicalAlternative";
+const _MAL = "MedicalAlternativeList";
+const _MC = "MatchedCategories";
+const _MCD = "MatchedCategoryDetails";
+const _MD = "MatchedDetails";
+const _ME = "MedicalEntity";
+const _MEL = "MedicalEntityList";
+const _MEe = "MediaEncoding";
+const _MI = "MedicalItem";
+const _MIL = "MedicalItemList";
+const _MR = "MedicalResult";
+const _MRL = "MedicalResultList";
+const _MSAE = "MedicalScribeAudioEvent";
+const _MSC = "MedicalScribeContext";
+const _MSCD = "MedicalScribeChannelDefinition";
+const _MSCDe = "MedicalScribeChannelDefinitions";
+const _MSCE = "MedicalScribeConfigurationEvent";
+const _MSCP = "MedicalScribeContextProvided";
+const _MSES = "MedicalScribeEncryptionSettings";
+const _MSIS = "MedicalScribeInputStream";
+const _MSPC = "MedicalScribePatientContext";
+const _MSPSAR = "MedicalScribePostStreamAnalyticsResult";
+const _MSPSAS = "MedicalScribePostStreamAnalyticsSettings";
 const _MSRH = "MediaSampleRateHertz";
+const _MSRS = "MedicalScribeResultStream";
+const _MSSCE = "MedicalScribeSessionControlEvent";
+const _MSSD = "MedicalScribeStreamDetails";
+const _MSTE = "MedicalScribeTranscriptEvent";
+const _MSTI = "MedicalScribeTranscriptItem";
+const _MSTIL = "MedicalScribeTranscriptItemList";
+const _MSTS = "MedicalScribeTranscriptSegment";
+const _MT = "MedicalTranscript";
+const _MTE = "MedicalTranscriptEvent";
+const _MTRS = "MedicalTranscriptResultStream";
 const _NOC = "NumberOfChannels";
+const _NT = "NoteTemplate";
+const _OBN = "OutputBucketName";
+const _OEKMSKI = "OutputEncryptionKMSKeyId";
+const _OL = "OutputLocation";
+const _P = "Pronouns";
+const _PC = "PatientContext";
+const _PCAS = "PostCallAnalyticsSettings";
 const _PET = "PiiEntityTypes";
 const _PL = "PreferredLanguage";
+const _POI = "PointsOfInterest";
+const _PR = "ParticipantRole";
 const _PRS = "PartialResultsStability";
-const _RI = "RequestId";
-const _S = "Specialty";
+const _PSAR = "PostStreamAnalyticsResult";
+const _PSAS = "PostStreamAnalyticsSettings";
+const _R = "Results";
+const _RARA = "ResourceAccessRoleArn";
+const _RI = "ResultId";
+const _RIe = "RequestId";
+const _RL = "ResultList";
+const _RNFE = "ResourceNotFoundException";
+const _RS = "ResultStream";
+const _Re = "Result";
+const _S = "Stable";
+const _SCA = "StreamCreatedAt";
+const _SCAST = "StartCallAnalyticsStreamTranscription";
+const _SCASTR = "StartCallAnalyticsStreamTranscriptionRequest";
+const _SCASTRt = "StartCallAnalyticsStreamTranscriptionResponse";
+const _SCE = "SessionControlEvent";
+const _SEA = "StreamEndedAt";
 const _SI = "SessionId";
+const _SIe = "SegmentId";
+const _SMSS = "StartMedicalScribeStream";
+const _SMSSR = "StartMedicalScribeStreamRequest";
+const _SMSSRt = "StartMedicalScribeStreamResponse";
+const _SMST = "StartMedicalStreamTranscription";
+const _SMSTR = "StartMedicalStreamTranscriptionRequest";
+const _SMSTRt = "StartMedicalStreamTranscriptionResponse";
+const _SS = "StreamStatus";
 const _SSL = "ShowSpeakerLabel";
-const _T = "Type";
-const _VFM = "VocabularyFilterMethod";
+const _SST = "StartStreamTranscription";
+const _SSTR = "StartStreamTranscriptionRequest";
+const _SSTRt = "StartStreamTranscriptionResponse";
+const _ST = "StartTime";
+const _SUE = "ServiceUnavailableException";
+const _Sc = "Score";
+const _Se = "Sentiment";
+const _Sp = "Speaker";
+const _Spe = "Specialty";
+const _St = "Status";
+const _T = "Transcript";
+const _TE = "TranscriptEvent";
+const _TOL = "TranscriptOutputLocation";
+const _TR = "TimestampRanges";
+const _TRS = "TranscriptResultStream";
+const _TRi = "TimestampRange";
+const _TS = "TranscriptSegment";
+const _Ty = "Type";
+const _UE = "UtteranceEvent";
+const _UI = "UtteranceId";
+const _VFM = "VocabularyFilterMatch";
+const _VFMo = "VocabularyFilterMethod";
 const _VFN = "VocabularyFilterName";
 const _VFNo = "VocabularyFilterNames";
 const _VN = "VocabularyName";
 const _VNo = "VocabularyNames";
+const _c = "client";
+const _e = "error";
+const _eP = "eventPayload";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _s = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.transcribestreaming";
+const _st = "streaming";
 const _xari = "x-amzn-request-id";
 const _xatcit = "x-amzn-transcribe-content-identification-type";
 const _xatcrt = "x-amzn-transcribe-content-redaction-type";
@@ -1587,21 +676,1343 @@ const _xatvfn = "x-amzn-transcribe-vocabulary-filter-name";
 const _xatvfn_ = "x-amzn-transcribe-vocabulary-filter-names";
 const _xatvn = "x-amzn-transcribe-vocabulary-name";
 const _xatvn_ = "x-amzn-transcribe-vocabulary-names";
+const n0 = "com.amazonaws.transcribestreaming";
+var Pronouns = [0, n0, _P, 8, 0];
+var Alternative = [3, n0, _A, 0, [_T, _I, _E], [0, () => ItemList, () => EntityList]];
+var AudioEvent = [
+    3,
+    n0,
+    _AE,
+    0,
+    [_AC],
+    [
+        [
+            21,
+            {
+                [_eP]: 1,
+            },
+        ],
+    ],
+];
+var BadRequestException = [
+    -3,
+    n0,
+    _BRE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(BadRequestException, BadRequestException$1);
+var CallAnalyticsEntity = [
+    3,
+    n0,
+    _CAE,
+    0,
+    [_BOM, _EOM, _C, _Ty, _Co, _Con],
+    [1, 1, 0, 0, 0, 1],
+];
+var CallAnalyticsItem = [
+    3,
+    n0,
+    _CAI,
+    0,
+    [_BOM, _EOM, _Ty, _Co, _Con, _VFM, _S],
+    [1, 1, 0, 0, 1, 2, 2],
+];
+var CallAnalyticsLanguageWithScore = [3, n0, _CALWS, 0, [_LC, _Sc], [0, 1]];
+var CategoryEvent = [3, n0, _CE, 0, [_MC, _MD], [64 | 0, () => MatchedCategoryDetails]];
+var ChannelDefinition = [3, n0, _CD, 0, [_CI, _PR], [1, 0]];
+var CharacterOffsets = [3, n0, _CO, 0, [_B, _En], [1, 1]];
+var ClinicalNoteGenerationResult = [
+    3,
+    n0,
+    _CNGR,
+    0,
+    [_CNOL, _TOL, _St, _FR],
+    [0, 0, 0, 0],
+];
+var ClinicalNoteGenerationSettings = [3, n0, _CNGS, 0, [_OBN, _NT], [0, 0]];
+var ConfigurationEvent = [
+    3,
+    n0,
+    _CEo,
+    0,
+    [_CDh, _PCAS],
+    [() => ChannelDefinitions, () => PostCallAnalyticsSettings],
+];
+var ConflictException = [
+    -3,
+    n0,
+    _CEon,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var Entity = [3, n0, _Ent, 0, [_ST, _ET, _C, _Ty, _Co, _Con], [1, 1, 0, 0, 0, 1]];
+var GetMedicalScribeStreamRequest = [3, n0, _GMSSR, 0, [_SI], [[0, 1]]];
+var GetMedicalScribeStreamResponse = [
+    3,
+    n0,
+    _GMSSRe,
+    0,
+    [_MSSD],
+    [() => MedicalScribeStreamDetails],
+];
+var InternalFailureException = [
+    -3,
+    n0,
+    _IFE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalFailureException, InternalFailureException$1);
+var IssueDetected = [3, n0, _ID, 0, [_CO], [() => CharacterOffsets]];
+var Item = [
+    3,
+    n0,
+    _It,
+    0,
+    [_ST, _ET, _Ty, _Co, _VFM, _Sp, _Con, _S],
+    [1, 1, 0, 0, 2, 0, 1, 2],
+];
+var LanguageWithScore = [3, n0, _LWS, 0, [_LC, _Sc], [0, 1]];
+var LimitExceededException = [
+    -3,
+    n0,
+    _LEE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LimitExceededException, LimitExceededException$1);
+var MedicalAlternative = [
+    3,
+    n0,
+    _MA,
+    0,
+    [_T, _I, _E],
+    [0, () => MedicalItemList, () => MedicalEntityList],
+];
+var MedicalEntity = [3, n0, _ME, 0, [_ST, _ET, _C, _Co, _Con], [1, 1, 0, 0, 1]];
+var MedicalItem = [3, n0, _MI, 0, [_ST, _ET, _Ty, _Co, _Con, _Sp], [1, 1, 0, 0, 1, 0]];
+var MedicalResult = [
+    3,
+    n0,
+    _MR,
+    0,
+    [_RI, _ST, _ET, _IP, _Al, _CI],
+    [0, 1, 1, 2, () => MedicalAlternativeList, 0],
+];
+var MedicalScribeAudioEvent = [
+    3,
+    n0,
+    _MSAE,
+    0,
+    [_AC],
+    [
+        [
+            21,
+            {
+                [_eP]: 1,
+            },
+        ],
+    ],
+];
+var MedicalScribeChannelDefinition = [3, n0, _MSCD, 0, [_CI, _PR], [1, 0]];
+var MedicalScribeConfigurationEvent = [
+    3,
+    n0,
+    _MSCE,
+    0,
+    [_VN, _VFN, _VFMo, _RARA, _CDh, _ES, _PSAS, _MSC],
+    [
+        0,
+        0,
+        0,
+        0,
+        () => MedicalScribeChannelDefinitions,
+        () => MedicalScribeEncryptionSettings,
+        () => MedicalScribePostStreamAnalyticsSettings,
+        [() => MedicalScribeContext, 0],
+    ],
+];
+var MedicalScribeContext = [
+    3,
+    n0,
+    _MSC,
+    0,
+    [_PC],
+    [[() => MedicalScribePatientContext, 0]],
+];
+var MedicalScribeEncryptionSettings = [3, n0, _MSES, 0, [_KEC, _KKI], [128 | 0, 0]];
+var MedicalScribePatientContext = [3, n0, _MSPC, 0, [_P], [[() => Pronouns, 0]]];
+var MedicalScribePostStreamAnalyticsResult = [
+    3,
+    n0,
+    _MSPSAR,
+    0,
+    [_CNGR],
+    [() => ClinicalNoteGenerationResult],
+];
+var MedicalScribePostStreamAnalyticsSettings = [
+    3,
+    n0,
+    _MSPSAS,
+    0,
+    [_CNGS],
+    [() => ClinicalNoteGenerationSettings],
+];
+var MedicalScribeSessionControlEvent = [3, n0, _MSSCE, 0, [_Ty], [0]];
+var MedicalScribeStreamDetails = [
+    3,
+    n0,
+    _MSSD,
+    0,
+    [_SI, _SCA, _SEA, _LC, _MSRH, _MEe, _VN, _VFN, _VFMo, _RARA, _CDh, _ES, _SS, _PSAS, _PSAR, _MSCP],
+    [
+        0,
+        4,
+        4,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        () => MedicalScribeChannelDefinitions,
+        () => MedicalScribeEncryptionSettings,
+        0,
+        () => MedicalScribePostStreamAnalyticsSettings,
+        () => MedicalScribePostStreamAnalyticsResult,
+        2,
+    ],
+];
+var MedicalScribeTranscriptEvent = [
+    3,
+    n0,
+    _MSTE,
+    0,
+    [_TS],
+    [() => MedicalScribeTranscriptSegment],
+];
+var MedicalScribeTranscriptItem = [
+    3,
+    n0,
+    _MSTI,
+    0,
+    [_BAT, _EAT, _Ty, _Con, _Co, _VFM],
+    [1, 1, 0, 1, 0, 2],
+];
+var MedicalScribeTranscriptSegment = [
+    3,
+    n0,
+    _MSTS,
+    0,
+    [_SIe, _BAT, _EAT, _Co, _I, _IP, _CI],
+    [0, 1, 1, 0, () => MedicalScribeTranscriptItemList, 2, 0],
+];
+var MedicalTranscript = [3, n0, _MT, 0, [_R], [() => MedicalResultList]];
+var MedicalTranscriptEvent = [3, n0, _MTE, 0, [_T], [() => MedicalTranscript]];
+var PointsOfInterest = [3, n0, _POI, 0, [_TR], [() => TimestampRanges]];
+var PostCallAnalyticsSettings = [
+    3,
+    n0,
+    _PCAS,
+    0,
+    [_OL, _DARA, _CRO, _OEKMSKI],
+    [0, 0, 0, 0],
+];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var Result = [
+    3,
+    n0,
+    _Re,
+    0,
+    [_RI, _ST, _ET, _IP, _Al, _CI, _LC, _LI],
+    [0, 1, 1, 2, () => AlternativeList, 0, 0, () => LanguageIdentification],
+];
+var ServiceUnavailableException = [
+    -3,
+    n0,
+    _SUE,
+    {
+        [_e]: _s,
+        [_hE]: 503,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceUnavailableException, ServiceUnavailableException$1);
+var StartCallAnalyticsStreamTranscriptionRequest = [
+    3,
+    n0,
+    _SCASTR,
+    0,
+    [_LC, _MSRH, _MEe, _VN, _SI, _AS, _VFN, _VFMo, _LMN, _IL, _LO, _PL, _VNo, _VFNo, _EPRS, _PRS, _CIT, _CRT, _PET],
+    [
+        [
+            0,
+            {
+                [_hH]: _xatlc,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _xatsr,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatme,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvn,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatsi,
+            },
+        ],
+        [() => AudioStream, 16],
+        [
+            0,
+            {
+                [_hH]: _xatvfn,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvfm,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatlmn,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xatil,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatlo,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatpl,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvn_,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvfn_,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xateprs,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatprs,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatcit,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatcrt,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatpet,
+            },
+        ],
+    ],
+];
+var StartCallAnalyticsStreamTranscriptionResponse = [
+    3,
+    n0,
+    _SCASTRt,
+    0,
+    [
+        _RIe,
+        _LC,
+        _MSRH,
+        _MEe,
+        _VN,
+        _SI,
+        _CATRS,
+        _VFN,
+        _VFMo,
+        _LMN,
+        _IL,
+        _LO,
+        _PL,
+        _VNo,
+        _VFNo,
+        _EPRS,
+        _PRS,
+        _CIT,
+        _CRT,
+        _PET,
+    ],
+    [
+        [
+            0,
+            {
+                [_hH]: _xari,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatlc,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _xatsr,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatme,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvn,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatsi,
+            },
+        ],
+        [() => CallAnalyticsTranscriptResultStream, 16],
+        [
+            0,
+            {
+                [_hH]: _xatvfn,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvfm,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatlmn,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xatil,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatlo,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatpl,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvn_,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvfn_,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xateprs,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatprs,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatcit,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatcrt,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatpet,
+            },
+        ],
+    ],
+];
+var StartMedicalScribeStreamRequest = [
+    3,
+    n0,
+    _SMSSR,
+    0,
+    [_SI, _LC, _MSRH, _MEe, _IS],
+    [
+        [
+            0,
+            {
+                [_hH]: _xatsi,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatlc,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _xatsr,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatme,
+            },
+        ],
+        [() => MedicalScribeInputStream, 16],
+    ],
+];
+var StartMedicalScribeStreamResponse = [
+    3,
+    n0,
+    _SMSSRt,
+    0,
+    [_SI, _RIe, _LC, _MSRH, _MEe, _RS],
+    [
+        [
+            0,
+            {
+                [_hH]: _xatsi,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xari,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatlc,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _xatsr,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatme,
+            },
+        ],
+        [() => MedicalScribeResultStream, 16],
+    ],
+];
+var StartMedicalStreamTranscriptionRequest = [
+    3,
+    n0,
+    _SMSTR,
+    0,
+    [_LC, _MSRH, _MEe, _VN, _Spe, _Ty, _SSL, _SI, _AS, _ECI, _NOC, _CIT],
+    [
+        [
+            0,
+            {
+                [_hH]: _xatlc,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _xatsr,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatme,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvn,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xats,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatt,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xatssl,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatsi,
+            },
+        ],
+        [() => AudioStream, 16],
+        [
+            2,
+            {
+                [_hH]: _xateci,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _xatnoc,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatcit,
+            },
+        ],
+    ],
+];
+var StartMedicalStreamTranscriptionResponse = [
+    3,
+    n0,
+    _SMSTRt,
+    0,
+    [_RIe, _LC, _MSRH, _MEe, _VN, _Spe, _Ty, _SSL, _SI, _TRS, _ECI, _NOC, _CIT],
+    [
+        [
+            0,
+            {
+                [_hH]: _xari,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatlc,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _xatsr,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatme,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvn,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xats,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatt,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xatssl,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatsi,
+            },
+        ],
+        [() => MedicalTranscriptResultStream, 16],
+        [
+            2,
+            {
+                [_hH]: _xateci,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _xatnoc,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatcit,
+            },
+        ],
+    ],
+];
+var StartStreamTranscriptionRequest = [
+    3,
+    n0,
+    _SSTR,
+    0,
+    [
+        _LC,
+        _MSRH,
+        _MEe,
+        _VN,
+        _SI,
+        _AS,
+        _VFN,
+        _VFMo,
+        _SSL,
+        _ECI,
+        _NOC,
+        _EPRS,
+        _PRS,
+        _CIT,
+        _CRT,
+        _PET,
+        _LMN,
+        _IL,
+        _LO,
+        _PL,
+        _IML,
+        _VNo,
+        _VFNo,
+    ],
+    [
+        [
+            0,
+            {
+                [_hH]: _xatlc,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _xatsr,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatme,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvn,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatsi,
+            },
+        ],
+        [() => AudioStream, 16],
+        [
+            0,
+            {
+                [_hH]: _xatvfn,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvfm,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xatssl,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xateci,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _xatnoc,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xateprs,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatprs,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatcit,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatcrt,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatpet,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatlmn,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xatil,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatlo,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatpl,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xatiml,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvn_,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvfn_,
+            },
+        ],
+    ],
+];
+var StartStreamTranscriptionResponse = [
+    3,
+    n0,
+    _SSTRt,
+    0,
+    [
+        _RIe,
+        _LC,
+        _MSRH,
+        _MEe,
+        _VN,
+        _SI,
+        _TRS,
+        _VFN,
+        _VFMo,
+        _SSL,
+        _ECI,
+        _NOC,
+        _EPRS,
+        _PRS,
+        _CIT,
+        _CRT,
+        _PET,
+        _LMN,
+        _IL,
+        _LO,
+        _PL,
+        _IML,
+        _VNo,
+        _VFNo,
+    ],
+    [
+        [
+            0,
+            {
+                [_hH]: _xari,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatlc,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _xatsr,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatme,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvn,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatsi,
+            },
+        ],
+        [() => TranscriptResultStream, 16],
+        [
+            0,
+            {
+                [_hH]: _xatvfn,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvfm,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xatssl,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xateci,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _xatnoc,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xateprs,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatprs,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatcit,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatcrt,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatpet,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatlmn,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xatil,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatlo,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatpl,
+            },
+        ],
+        [
+            2,
+            {
+                [_hH]: _xatiml,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvn_,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xatvfn_,
+            },
+        ],
+    ],
+];
+var TimestampRange = [3, n0, _TRi, 0, [_BOM, _EOM], [1, 1]];
+var Transcript = [3, n0, _T, 0, [_R], [() => ResultList]];
+var TranscriptEvent = [3, n0, _TE, 0, [_T], [() => Transcript]];
+var UtteranceEvent = [
+    3,
+    n0,
+    _UE,
+    0,
+    [_UI, _IP, _PR, _BOM, _EOM, _T, _I, _E, _Se, _IDs, _LC, _LI],
+    [
+        0,
+        2,
+        0,
+        1,
+        1,
+        0,
+        () => CallAnalyticsItemList,
+        () => CallAnalyticsEntityList,
+        0,
+        () => IssuesDetected,
+        0,
+        () => CallAnalyticsLanguageIdentification,
+    ],
+];
+var TranscribeStreamingServiceException = [
+    -3,
+    _sm,
+    "TranscribeStreamingServiceException",
+    0,
+    [],
+    [],
+];
+schema.TypeRegistry.for(_sm).registerError(TranscribeStreamingServiceException, TranscribeStreamingServiceException$1);
+var AlternativeList = [1, n0, _AL, 0, () => Alternative];
+var CallAnalyticsEntityList = [1, n0, _CAEL, 0, () => CallAnalyticsEntity];
+var CallAnalyticsItemList = [1, n0, _CAIL, 0, () => CallAnalyticsItem];
+var CallAnalyticsLanguageIdentification = [
+    1,
+    n0,
+    _CALI,
+    0,
+    () => CallAnalyticsLanguageWithScore,
+];
+var ChannelDefinitions = [1, n0, _CDh, 0, () => ChannelDefinition];
+var EntityList = [1, n0, _EL, 0, () => Entity];
+var IssuesDetected = [1, n0, _IDs, 0, () => IssueDetected];
+var ItemList = [1, n0, _ILt, 0, () => Item];
+var LanguageIdentification = [1, n0, _LI, 0, () => LanguageWithScore];
+var MedicalAlternativeList = [1, n0, _MAL, 0, () => MedicalAlternative];
+var MedicalEntityList = [1, n0, _MEL, 0, () => MedicalEntity];
+var MedicalItemList = [1, n0, _MIL, 0, () => MedicalItem];
+var MedicalResultList = [1, n0, _MRL, 0, () => MedicalResult];
+var MedicalScribeChannelDefinitions = [1, n0, _MSCDe, 0, () => MedicalScribeChannelDefinition];
+var MedicalScribeTranscriptItemList = [1, n0, _MSTIL, 0, () => MedicalScribeTranscriptItem];
+var ResultList = [1, n0, _RL, 0, () => Result];
+var TimestampRanges = [1, n0, _TR, 0, () => TimestampRange];
+var MatchedCategoryDetails = [2, n0, _MCD, 0, 0, () => PointsOfInterest];
+var AudioStream = [
+    3,
+    n0,
+    _AS,
+    {
+        [_st]: 1,
+    },
+    [_AE, _CEo],
+    [[() => AudioEvent, 0], () => ConfigurationEvent],
+];
+var CallAnalyticsTranscriptResultStream = [
+    3,
+    n0,
+    _CATRS,
+    {
+        [_st]: 1,
+    },
+    [_UE, _CE, _BRE, _LEE, _IFE, _CEon, _SUE],
+    [
+        () => UtteranceEvent,
+        () => CategoryEvent,
+        [() => BadRequestException, 0],
+        [() => LimitExceededException, 0],
+        [() => InternalFailureException, 0],
+        [() => ConflictException, 0],
+        [() => ServiceUnavailableException, 0],
+    ],
+];
+var MedicalScribeInputStream = [
+    3,
+    n0,
+    _MSIS,
+    {
+        [_st]: 1,
+    },
+    [_AE, _SCE, _CEo],
+    [
+        [() => MedicalScribeAudioEvent, 0],
+        () => MedicalScribeSessionControlEvent,
+        [() => MedicalScribeConfigurationEvent, 0],
+    ],
+];
+var MedicalScribeResultStream = [
+    3,
+    n0,
+    _MSRS,
+    {
+        [_st]: 1,
+    },
+    [_TE, _BRE, _LEE, _IFE, _CEon, _SUE],
+    [
+        () => MedicalScribeTranscriptEvent,
+        [() => BadRequestException, 0],
+        [() => LimitExceededException, 0],
+        [() => InternalFailureException, 0],
+        [() => ConflictException, 0],
+        [() => ServiceUnavailableException, 0],
+    ],
+];
+var MedicalTranscriptResultStream = [
+    3,
+    n0,
+    _MTRS,
+    {
+        [_st]: 1,
+    },
+    [_TE, _BRE, _LEE, _IFE, _CEon, _SUE],
+    [
+        () => MedicalTranscriptEvent,
+        [() => BadRequestException, 0],
+        [() => LimitExceededException, 0],
+        [() => InternalFailureException, 0],
+        [() => ConflictException, 0],
+        [() => ServiceUnavailableException, 0],
+    ],
+];
+var TranscriptResultStream = [
+    3,
+    n0,
+    _TRS,
+    {
+        [_st]: 1,
+    },
+    [_TE, _BRE, _LEE, _IFE, _CEon, _SUE],
+    [
+        () => TranscriptEvent,
+        [() => BadRequestException, 0],
+        [() => LimitExceededException, 0],
+        [() => InternalFailureException, 0],
+        [() => ConflictException, 0],
+        [() => ServiceUnavailableException, 0],
+    ],
+];
+var GetMedicalScribeStream = [
+    9,
+    n0,
+    _GMSS,
+    {
+        [_h]: ["GET", "/medical-scribe-stream/{SessionId}", 200],
+    },
+    () => GetMedicalScribeStreamRequest,
+    () => GetMedicalScribeStreamResponse,
+];
+var StartCallAnalyticsStreamTranscription = [
+    9,
+    n0,
+    _SCAST,
+    {
+        [_h]: ["POST", "/call-analytics-stream-transcription", 200],
+    },
+    () => StartCallAnalyticsStreamTranscriptionRequest,
+    () => StartCallAnalyticsStreamTranscriptionResponse,
+];
+var StartMedicalScribeStream = [
+    9,
+    n0,
+    _SMSS,
+    {
+        [_h]: ["POST", "/medical-scribe-stream", 200],
+    },
+    () => StartMedicalScribeStreamRequest,
+    () => StartMedicalScribeStreamResponse,
+];
+var StartMedicalStreamTranscription = [
+    9,
+    n0,
+    _SMST,
+    {
+        [_h]: ["POST", "/medical-stream-transcription", 200],
+    },
+    () => StartMedicalStreamTranscriptionRequest,
+    () => StartMedicalStreamTranscriptionResponse,
+];
+var StartStreamTranscription = [
+    9,
+    n0,
+    _SST,
+    {
+        [_h]: ["POST", "/stream-transcription", 200],
+    },
+    () => StartStreamTranscriptionRequest,
+    () => StartStreamTranscriptionResponse,
+];
 
 class GetMedicalScribeStreamCommand 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("Transcribe", "GetMedicalScribeStream", {})
     .n("TranscribeStreamingClient", "GetMedicalScribeStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_GetMedicalScribeStreamCommand)
-    .de(de_GetMedicalScribeStreamCommand)
+    .sc(GetMedicalScribeStream)
     .build() {
 }
 
@@ -1610,7 +2021,6 @@ class StartCallAnalyticsStreamTranscriptionCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEventstream.getEventStreamPlugin(config),
         middlewareWebsocket.getWebSocketPlugin(config, {
@@ -1626,9 +2036,7 @@ class StartCallAnalyticsStreamTranscriptionCommand extends smithyClient.Command
     },
 })
     .n("TranscribeStreamingClient", "StartCallAnalyticsStreamTranscriptionCommand")
-    .f(StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog, StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog)
-    .ser(se_StartCallAnalyticsStreamTranscriptionCommand)
-    .de(de_StartCallAnalyticsStreamTranscriptionCommand)
+    .sc(StartCallAnalyticsStreamTranscription)
     .build() {
 }
 
@@ -1637,7 +2045,6 @@ class StartMedicalScribeStreamCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEventstream.getEventStreamPlugin(config),
         middlewareWebsocket.getWebSocketPlugin(config, {
@@ -1653,9 +2060,7 @@ class StartMedicalScribeStreamCommand extends smithyClient.Command
     },
 })
     .n("TranscribeStreamingClient", "StartMedicalScribeStreamCommand")
-    .f(StartMedicalScribeStreamRequestFilterSensitiveLog, StartMedicalScribeStreamResponseFilterSensitiveLog)
-    .ser(se_StartMedicalScribeStreamCommand)
-    .de(de_StartMedicalScribeStreamCommand)
+    .sc(StartMedicalScribeStream)
     .build() {
 }
 
@@ -1664,7 +2069,6 @@ class StartMedicalStreamTranscriptionCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEventstream.getEventStreamPlugin(config),
         middlewareWebsocket.getWebSocketPlugin(config, {
@@ -1680,9 +2084,7 @@ class StartMedicalStreamTranscriptionCommand extends smithyClient.Command
     },
 })
     .n("TranscribeStreamingClient", "StartMedicalStreamTranscriptionCommand")
-    .f(StartMedicalStreamTranscriptionRequestFilterSensitiveLog, StartMedicalStreamTranscriptionResponseFilterSensitiveLog)
-    .ser(se_StartMedicalStreamTranscriptionCommand)
-    .de(de_StartMedicalStreamTranscriptionCommand)
+    .sc(StartMedicalStreamTranscription)
     .build() {
 }
 
@@ -1691,7 +2093,6 @@ class StartStreamTranscriptionCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEventstream.getEventStreamPlugin(config),
         middlewareWebsocket.getWebSocketPlugin(config, {
@@ -1707,9 +2108,7 @@ class StartStreamTranscriptionCommand extends smithyClient.Command
     },
 })
     .n("TranscribeStreamingClient", "StartStreamTranscriptionCommand")
-    .f(StartStreamTranscriptionRequestFilterSensitiveLog, StartStreamTranscriptionResponseFilterSensitiveLog)
-    .ser(se_StartStreamTranscriptionCommand)
-    .de(de_StartStreamTranscriptionCommand)
+    .sc(StartStreamTranscription)
     .build() {
 }
 
@@ -1732,58 +2131,41 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AudioStreamFilterSensitiveLog = AudioStreamFilterSensitiveLog;
-exports.BadRequestException = BadRequestException;
+exports.BadRequestException = BadRequestException$1;
 exports.CallAnalyticsLanguageCode = CallAnalyticsLanguageCode;
-exports.CallAnalyticsTranscriptResultStreamFilterSensitiveLog = CallAnalyticsTranscriptResultStreamFilterSensitiveLog;
 exports.ClinicalNoteGenerationStatus = ClinicalNoteGenerationStatus;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.ContentIdentificationType = ContentIdentificationType;
 exports.ContentRedactionOutput = ContentRedactionOutput;
 exports.ContentRedactionType = ContentRedactionType;
 exports.GetMedicalScribeStreamCommand = GetMedicalScribeStreamCommand;
-exports.InternalFailureException = InternalFailureException;
+exports.InternalFailureException = InternalFailureException$1;
 exports.ItemType = ItemType;
 exports.LanguageCode = LanguageCode;
-exports.LimitExceededException = LimitExceededException;
+exports.LimitExceededException = LimitExceededException$1;
 exports.MediaEncoding = MediaEncoding;
 exports.MedicalContentIdentificationType = MedicalContentIdentificationType;
-exports.MedicalScribeConfigurationEventFilterSensitiveLog = MedicalScribeConfigurationEventFilterSensitiveLog;
-exports.MedicalScribeContextFilterSensitiveLog = MedicalScribeContextFilterSensitiveLog;
-exports.MedicalScribeInputStreamFilterSensitiveLog = MedicalScribeInputStreamFilterSensitiveLog;
 exports.MedicalScribeLanguageCode = MedicalScribeLanguageCode;
 exports.MedicalScribeMediaEncoding = MedicalScribeMediaEncoding;
 exports.MedicalScribeNoteTemplate = MedicalScribeNoteTemplate;
 exports.MedicalScribeParticipantRole = MedicalScribeParticipantRole;
-exports.MedicalScribePatientContextFilterSensitiveLog = MedicalScribePatientContextFilterSensitiveLog;
-exports.MedicalScribeResultStreamFilterSensitiveLog = MedicalScribeResultStreamFilterSensitiveLog;
 exports.MedicalScribeSessionControlEventType = MedicalScribeSessionControlEventType;
 exports.MedicalScribeStreamStatus = MedicalScribeStreamStatus;
 exports.MedicalScribeTranscriptItemType = MedicalScribeTranscriptItemType;
 exports.MedicalScribeVocabularyFilterMethod = MedicalScribeVocabularyFilterMethod;
-exports.MedicalTranscriptResultStreamFilterSensitiveLog = MedicalTranscriptResultStreamFilterSensitiveLog;
 exports.PartialResultsStability = PartialResultsStability;
 exports.ParticipantRole = ParticipantRole;
-exports.Pronouns = Pronouns;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.Pronouns = Pronouns$1;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.Sentiment = Sentiment;
-exports.ServiceUnavailableException = ServiceUnavailableException;
+exports.ServiceUnavailableException = ServiceUnavailableException$1;
 exports.Specialty = Specialty;
 exports.StartCallAnalyticsStreamTranscriptionCommand = StartCallAnalyticsStreamTranscriptionCommand;
-exports.StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog = StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog;
-exports.StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog = StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog;
 exports.StartMedicalScribeStreamCommand = StartMedicalScribeStreamCommand;
-exports.StartMedicalScribeStreamRequestFilterSensitiveLog = StartMedicalScribeStreamRequestFilterSensitiveLog;
-exports.StartMedicalScribeStreamResponseFilterSensitiveLog = StartMedicalScribeStreamResponseFilterSensitiveLog;
 exports.StartMedicalStreamTranscriptionCommand = StartMedicalStreamTranscriptionCommand;
-exports.StartMedicalStreamTranscriptionRequestFilterSensitiveLog = StartMedicalStreamTranscriptionRequestFilterSensitiveLog;
-exports.StartMedicalStreamTranscriptionResponseFilterSensitiveLog = StartMedicalStreamTranscriptionResponseFilterSensitiveLog;
 exports.StartStreamTranscriptionCommand = StartStreamTranscriptionCommand;
-exports.StartStreamTranscriptionRequestFilterSensitiveLog = StartStreamTranscriptionRequestFilterSensitiveLog;
-exports.StartStreamTranscriptionResponseFilterSensitiveLog = StartStreamTranscriptionResponseFilterSensitiveLog;
 exports.TranscribeStreaming = TranscribeStreaming;
 exports.TranscribeStreamingClient = TranscribeStreamingClient;
-exports.TranscribeStreamingServiceException = TranscribeStreamingServiceException;
-exports.TranscriptResultStreamFilterSensitiveLog = TranscriptResultStreamFilterSensitiveLog;
+exports.TranscribeStreamingServiceException = TranscribeStreamingServiceException$1;
 exports.Type = Type;
 exports.VocabularyFilterMethod = VocabularyFilterMethod;