@aws-sdk/client-transcribe-streaming 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,11 +1,1487 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TranscribeStreamingServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./TranscribeStreamingClient"), exports);
-tslib_1.__exportStar(require("./TranscribeStreaming"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var TranscribeStreamingServiceException_1 = require("./models/TranscribeStreamingServiceException");
-Object.defineProperty(exports, "TranscribeStreamingServiceException", { enumerable: true, get: function () { return TranscribeStreamingServiceException_1.TranscribeStreamingServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AudioStream: () => AudioStream,
+  AudioStreamFilterSensitiveLog: () => AudioStreamFilterSensitiveLog,
+  BadRequestException: () => BadRequestException,
+  CallAnalyticsLanguageCode: () => CallAnalyticsLanguageCode,
+  CallAnalyticsTranscriptResultStream: () => CallAnalyticsTranscriptResultStream,
+  CallAnalyticsTranscriptResultStreamFilterSensitiveLog: () => CallAnalyticsTranscriptResultStreamFilterSensitiveLog,
+  ConflictException: () => ConflictException,
+  ContentIdentificationType: () => ContentIdentificationType,
+  ContentRedactionOutput: () => ContentRedactionOutput,
+  ContentRedactionType: () => ContentRedactionType,
+  InternalFailureException: () => InternalFailureException,
+  ItemType: () => ItemType,
+  LanguageCode: () => LanguageCode,
+  LimitExceededException: () => LimitExceededException,
+  MediaEncoding: () => MediaEncoding,
+  MedicalContentIdentificationType: () => MedicalContentIdentificationType,
+  MedicalTranscriptResultStream: () => MedicalTranscriptResultStream,
+  MedicalTranscriptResultStreamFilterSensitiveLog: () => MedicalTranscriptResultStreamFilterSensitiveLog,
+  PartialResultsStability: () => PartialResultsStability,
+  ParticipantRole: () => ParticipantRole,
+  Sentiment: () => Sentiment,
+  ServiceUnavailableException: () => ServiceUnavailableException,
+  Specialty: () => Specialty,
+  StartCallAnalyticsStreamTranscriptionCommand: () => StartCallAnalyticsStreamTranscriptionCommand,
+  StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog: () => StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog,
+  StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog: () => StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog,
+  StartMedicalStreamTranscriptionCommand: () => StartMedicalStreamTranscriptionCommand,
+  StartMedicalStreamTranscriptionRequestFilterSensitiveLog: () => StartMedicalStreamTranscriptionRequestFilterSensitiveLog,
+  StartMedicalStreamTranscriptionResponseFilterSensitiveLog: () => StartMedicalStreamTranscriptionResponseFilterSensitiveLog,
+  StartStreamTranscriptionCommand: () => StartStreamTranscriptionCommand,
+  StartStreamTranscriptionRequestFilterSensitiveLog: () => StartStreamTranscriptionRequestFilterSensitiveLog,
+  StartStreamTranscriptionResponseFilterSensitiveLog: () => StartStreamTranscriptionResponseFilterSensitiveLog,
+  TranscribeStreaming: () => TranscribeStreaming,
+  TranscribeStreamingClient: () => TranscribeStreamingClient,
+  TranscribeStreamingServiceException: () => TranscribeStreamingServiceException,
+  TranscriptResultStream: () => TranscriptResultStream,
+  TranscriptResultStreamFilterSensitiveLog: () => TranscriptResultStreamFilterSensitiveLog,
+  Type: () => Type,
+  VocabularyFilterMethod: () => VocabularyFilterMethod,
+  __Client: () => import_smithy_client.Client
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/TranscribeStreamingClient.ts
+var import_middleware_eventstream = require("@aws-sdk/middleware-eventstream");
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_sdk_transcribe_streaming = require("@aws-sdk/middleware-sdk-transcribe-streaming");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_middleware_websocket = require("@aws-sdk/middleware-websocket");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_eventstream_serde_config_resolver = require("@smithy/eventstream-serde-config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "transcribe"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/TranscribeStreamingClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/TranscribeStreamingClient.ts
+var _TranscribeStreamingClient = class _TranscribeStreamingClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_eventstream.resolveEventStreamConfig)(_config_6);
+    const _config_8 = (0, import_middleware_websocket.resolveWebSocketConfig)(_config_7);
+    const _config_9 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_8);
+    const _config_10 = (0, import_eventstream_serde_config_resolver.resolveEventStreamSerdeConfig)(_config_9);
+    const _config_11 = resolveRuntimeExtensions(_config_10, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_11);
+    this.config = _config_11;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_sdk_transcribe_streaming.getTranscribeStreamingPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_TranscribeStreamingClient, "TranscribeStreamingClient");
+var TranscribeStreamingClient = _TranscribeStreamingClient;
+
+// src/TranscribeStreaming.ts
+
+
+// src/commands/StartCallAnalyticsStreamTranscriptionCommand.ts
+
+
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/models/TranscribeStreamingServiceException.ts
+
+var _TranscribeStreamingServiceException = class _TranscribeStreamingServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _TranscribeStreamingServiceException.prototype);
+  }
+};
+__name(_TranscribeStreamingServiceException, "TranscribeStreamingServiceException");
+var TranscribeStreamingServiceException = _TranscribeStreamingServiceException;
+
+// src/models/models_0.ts
+var ItemType = {
+  PRONUNCIATION: "pronunciation",
+  PUNCTUATION: "punctuation"
+};
+var ParticipantRole = {
+  AGENT: "AGENT",
+  CUSTOMER: "CUSTOMER"
+};
+var ContentRedactionOutput = {
+  REDACTED: "redacted",
+  REDACTED_AND_UNREDACTED: "redacted_and_unredacted"
+};
+var AudioStream;
+((AudioStream2) => {
+  AudioStream2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.AudioEvent !== void 0)
+      return visitor.AudioEvent(value.AudioEvent);
+    if (value.ConfigurationEvent !== void 0)
+      return visitor.ConfigurationEvent(value.ConfigurationEvent);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(AudioStream || (AudioStream = {}));
+var _BadRequestException = class _BadRequestException extends TranscribeStreamingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "BadRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "BadRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _BadRequestException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_BadRequestException, "BadRequestException");
+var BadRequestException = _BadRequestException;
+var CallAnalyticsLanguageCode = {
+  DE_DE: "de-DE",
+  EN_AU: "en-AU",
+  EN_GB: "en-GB",
+  EN_US: "en-US",
+  ES_US: "es-US",
+  FR_CA: "fr-CA",
+  FR_FR: "fr-FR",
+  IT_IT: "it-IT",
+  PT_BR: "pt-BR"
+};
+var _ConflictException = class _ConflictException extends TranscribeStreamingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _InternalFailureException = class _InternalFailureException extends TranscribeStreamingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalFailureException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalFailureException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalFailureException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InternalFailureException, "InternalFailureException");
+var InternalFailureException = _InternalFailureException;
+var _LimitExceededException = class _LimitExceededException extends TranscribeStreamingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_LimitExceededException, "LimitExceededException");
+var LimitExceededException = _LimitExceededException;
+var _ServiceUnavailableException = class _ServiceUnavailableException extends TranscribeStreamingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceUnavailableException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "ServiceUnavailableException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _ServiceUnavailableException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ServiceUnavailableException, "ServiceUnavailableException");
+var ServiceUnavailableException = _ServiceUnavailableException;
+var Sentiment = {
+  MIXED: "MIXED",
+  NEGATIVE: "NEGATIVE",
+  NEUTRAL: "NEUTRAL",
+  POSITIVE: "POSITIVE"
+};
+var CallAnalyticsTranscriptResultStream;
+((CallAnalyticsTranscriptResultStream3) => {
+  CallAnalyticsTranscriptResultStream3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.UtteranceEvent !== void 0)
+      return visitor.UtteranceEvent(value.UtteranceEvent);
+    if (value.CategoryEvent !== void 0)
+      return visitor.CategoryEvent(value.CategoryEvent);
+    if (value.BadRequestException !== void 0)
+      return visitor.BadRequestException(value.BadRequestException);
+    if (value.LimitExceededException !== void 0)
+      return visitor.LimitExceededException(value.LimitExceededException);
+    if (value.InternalFailureException !== void 0)
+      return visitor.InternalFailureException(value.InternalFailureException);
+    if (value.ConflictException !== void 0)
+      return visitor.ConflictException(value.ConflictException);
+    if (value.ServiceUnavailableException !== void 0)
+      return visitor.ServiceUnavailableException(value.ServiceUnavailableException);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(CallAnalyticsTranscriptResultStream || (CallAnalyticsTranscriptResultStream = {}));
+var ContentIdentificationType = {
+  PII: "PII"
+};
+var ContentRedactionType = {
+  PII: "PII"
+};
+var LanguageCode = {
+  DE_DE: "de-DE",
+  EN_AU: "en-AU",
+  EN_GB: "en-GB",
+  EN_US: "en-US",
+  ES_US: "es-US",
+  FR_CA: "fr-CA",
+  FR_FR: "fr-FR",
+  HI_IN: "hi-IN",
+  IT_IT: "it-IT",
+  JA_JP: "ja-JP",
+  KO_KR: "ko-KR",
+  PT_BR: "pt-BR",
+  TH_TH: "th-TH",
+  ZH_CN: "zh-CN"
+};
+var MediaEncoding = {
+  FLAC: "flac",
+  OGG_OPUS: "ogg-opus",
+  PCM: "pcm"
+};
+var MedicalContentIdentificationType = {
+  PHI: "PHI"
+};
+var MedicalTranscriptResultStream;
+((MedicalTranscriptResultStream3) => {
+  MedicalTranscriptResultStream3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.TranscriptEvent !== void 0)
+      return visitor.TranscriptEvent(value.TranscriptEvent);
+    if (value.BadRequestException !== void 0)
+      return visitor.BadRequestException(value.BadRequestException);
+    if (value.LimitExceededException !== void 0)
+      return visitor.LimitExceededException(value.LimitExceededException);
+    if (value.InternalFailureException !== void 0)
+      return visitor.InternalFailureException(value.InternalFailureException);
+    if (value.ConflictException !== void 0)
+      return visitor.ConflictException(value.ConflictException);
+    if (value.ServiceUnavailableException !== void 0)
+      return visitor.ServiceUnavailableException(value.ServiceUnavailableException);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(MedicalTranscriptResultStream || (MedicalTranscriptResultStream = {}));
+var PartialResultsStability = {
+  HIGH: "high",
+  LOW: "low",
+  MEDIUM: "medium"
+};
+var Specialty = {
+  CARDIOLOGY: "CARDIOLOGY",
+  NEUROLOGY: "NEUROLOGY",
+  ONCOLOGY: "ONCOLOGY",
+  PRIMARYCARE: "PRIMARYCARE",
+  RADIOLOGY: "RADIOLOGY",
+  UROLOGY: "UROLOGY"
+};
+var VocabularyFilterMethod = {
+  MASK: "mask",
+  REMOVE: "remove",
+  TAG: "tag"
+};
+var Type = {
+  CONVERSATION: "CONVERSATION",
+  DICTATION: "DICTATION"
+};
+var TranscriptResultStream;
+((TranscriptResultStream3) => {
+  TranscriptResultStream3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.TranscriptEvent !== void 0)
+      return visitor.TranscriptEvent(value.TranscriptEvent);
+    if (value.BadRequestException !== void 0)
+      return visitor.BadRequestException(value.BadRequestException);
+    if (value.LimitExceededException !== void 0)
+      return visitor.LimitExceededException(value.LimitExceededException);
+    if (value.InternalFailureException !== void 0)
+      return visitor.InternalFailureException(value.InternalFailureException);
+    if (value.ConflictException !== void 0)
+      return visitor.ConflictException(value.ConflictException);
+    if (value.ServiceUnavailableException !== void 0)
+      return visitor.ServiceUnavailableException(value.ServiceUnavailableException);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(TranscriptResultStream || (TranscriptResultStream = {}));
+var AudioStreamFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.AudioEvent !== void 0)
+    return { AudioEvent: obj.AudioEvent };
+  if (obj.ConfigurationEvent !== void 0)
+    return { ConfigurationEvent: obj.ConfigurationEvent };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "AudioStreamFilterSensitiveLog");
+var CallAnalyticsTranscriptResultStreamFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.UtteranceEvent !== void 0)
+    return { UtteranceEvent: obj.UtteranceEvent };
+  if (obj.CategoryEvent !== void 0)
+    return { CategoryEvent: obj.CategoryEvent };
+  if (obj.BadRequestException !== void 0)
+    return { BadRequestException: obj.BadRequestException };
+  if (obj.LimitExceededException !== void 0)
+    return { LimitExceededException: obj.LimitExceededException };
+  if (obj.InternalFailureException !== void 0)
+    return { InternalFailureException: obj.InternalFailureException };
+  if (obj.ConflictException !== void 0)
+    return { ConflictException: obj.ConflictException };
+  if (obj.ServiceUnavailableException !== void 0)
+    return { ServiceUnavailableException: obj.ServiceUnavailableException };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "CallAnalyticsTranscriptResultStreamFilterSensitiveLog");
+var MedicalTranscriptResultStreamFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.TranscriptEvent !== void 0)
+    return { TranscriptEvent: obj.TranscriptEvent };
+  if (obj.BadRequestException !== void 0)
+    return { BadRequestException: obj.BadRequestException };
+  if (obj.LimitExceededException !== void 0)
+    return { LimitExceededException: obj.LimitExceededException };
+  if (obj.InternalFailureException !== void 0)
+    return { InternalFailureException: obj.InternalFailureException };
+  if (obj.ConflictException !== void 0)
+    return { ConflictException: obj.ConflictException };
+  if (obj.ServiceUnavailableException !== void 0)
+    return { ServiceUnavailableException: obj.ServiceUnavailableException };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "MedicalTranscriptResultStreamFilterSensitiveLog");
+var StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AudioStream && { AudioStream: "STREAMING_CONTENT" }
+}), "StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog");
+var StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.CallAnalyticsTranscriptResultStream && { CallAnalyticsTranscriptResultStream: "STREAMING_CONTENT" }
+}), "StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog");
+var StartMedicalStreamTranscriptionRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AudioStream && { AudioStream: "STREAMING_CONTENT" }
+}), "StartMedicalStreamTranscriptionRequestFilterSensitiveLog");
+var StartMedicalStreamTranscriptionResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.TranscriptResultStream && { TranscriptResultStream: "STREAMING_CONTENT" }
+}), "StartMedicalStreamTranscriptionResponseFilterSensitiveLog");
+var StartStreamTranscriptionRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.AudioStream && { AudioStream: "STREAMING_CONTENT" }
+}), "StartStreamTranscriptionRequestFilterSensitiveLog");
+var TranscriptResultStreamFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.TranscriptEvent !== void 0)
+    return { TranscriptEvent: obj.TranscriptEvent };
+  if (obj.BadRequestException !== void 0)
+    return { BadRequestException: obj.BadRequestException };
+  if (obj.LimitExceededException !== void 0)
+    return { LimitExceededException: obj.LimitExceededException };
+  if (obj.InternalFailureException !== void 0)
+    return { InternalFailureException: obj.InternalFailureException };
+  if (obj.ConflictException !== void 0)
+    return { ConflictException: obj.ConflictException };
+  if (obj.ServiceUnavailableException !== void 0)
+    return { ServiceUnavailableException: obj.ServiceUnavailableException };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "TranscriptResultStreamFilterSensitiveLog");
+var StartStreamTranscriptionResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.TranscriptResultStream && { TranscriptResultStream: "STREAMING_CONTENT" }
+}), "StartStreamTranscriptionResponseFilterSensitiveLog");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@smithy/core");
+
+var se_StartCallAnalyticsStreamTranscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    [_xatlc]: input[_LC],
+    [_xatsr]: [() => isSerializableHeaderValue(input[_MSRH]), () => input[_MSRH].toString()],
+    [_xatme]: input[_ME],
+    [_xatvn]: input[_VN],
+    [_xatsi]: input[_SI],
+    [_xatvfn]: input[_VFN],
+    [_xatvfm]: input[_VFM],
+    [_xatlmn]: input[_LMN],
+    [_xateprs]: [() => 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 !== void 0) {
+    body = se_AudioStream(input.AudioStream, context);
+  }
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartCallAnalyticsStreamTranscriptionCommand");
+var se_StartMedicalStreamTranscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    [_xatlc]: input[_LC],
+    [_xatsr]: [() => isSerializableHeaderValue(input[_MSRH]), () => input[_MSRH].toString()],
+    [_xatme]: input[_ME],
+    [_xatvn]: input[_VN],
+    [_xats]: input[_S],
+    [_xatt]: input[_T],
+    [_xatssl]: [() => isSerializableHeaderValue(input[_SSL]), () => input[_SSL].toString()],
+    [_xatsi]: input[_SI],
+    [_xateci]: [() => isSerializableHeaderValue(input[_ECI]), () => input[_ECI].toString()],
+    [_xatnoc]: [() => isSerializableHeaderValue(input[_NOC]), () => input[_NOC].toString()],
+    [_xatcit]: input[_CIT]
+  });
+  b.bp("/medical-stream-transcription");
+  let body;
+  if (input.AudioStream !== void 0) {
+    body = se_AudioStream(input.AudioStream, context);
+  }
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartMedicalStreamTranscriptionCommand");
+var se_StartStreamTranscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    [_xatlc]: input[_LC],
+    [_xatsr]: [() => isSerializableHeaderValue(input[_MSRH]), () => input[_MSRH].toString()],
+    [_xatme]: input[_ME],
+    [_xatvn]: input[_VN],
+    [_xatsi]: input[_SI],
+    [_xatvfn]: input[_VFN],
+    [_xatvfm]: input[_VFM],
+    [_xatssl]: [() => isSerializableHeaderValue(input[_SSL]), () => input[_SSL].toString()],
+    [_xateci]: [() => isSerializableHeaderValue(input[_ECI]), () => input[_ECI].toString()],
+    [_xatnoc]: [() => isSerializableHeaderValue(input[_NOC]), () => input[_NOC].toString()],
+    [_xateprs]: [() => isSerializableHeaderValue(input[_EPRS]), () => input[_EPRS].toString()],
+    [_xatprs]: input[_PRS],
+    [_xatcit]: input[_CIT],
+    [_xatcrt]: input[_CRT],
+    [_xatpet]: input[_PET],
+    [_xatlmn]: input[_LMN],
+    [_xatil]: [() => isSerializableHeaderValue(input[_IL]), () => input[_IL].toString()],
+    [_xatlo]: input[_LO],
+    [_xatpl]: input[_PL],
+    [_xatiml]: [() => isSerializableHeaderValue(input[_IML]), () => input[_IML].toString()],
+    [_xatvn_]: input[_VNo],
+    [_xatvfn_]: input[_VFNo]
+  });
+  b.bp("/stream-transcription");
+  let body;
+  if (input.AudioStream !== void 0) {
+    body = se_AudioStream(input.AudioStream, context);
+  }
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartStreamTranscriptionCommand");
+var de_StartCallAnalyticsStreamTranscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartCallAnalyticsStreamTranscriptionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_RI]: [, output.headers[_xari]],
+    [_LC]: [, output.headers[_xatlc]],
+    [_MSRH]: [() => void 0 !== output.headers[_xatsr], () => (0, import_smithy_client.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]],
+    [_EPRS]: [() => void 0 !== output.headers[_xateprs], () => (0, import_smithy_client.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;
+}, "de_StartCallAnalyticsStreamTranscriptionCommand");
+var de_StartCallAnalyticsStreamTranscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribestreaming#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribestreaming#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribestreaming#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribestreaming#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.transcribestreaming#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartCallAnalyticsStreamTranscriptionCommandError");
+var de_StartMedicalStreamTranscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartMedicalStreamTranscriptionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_RI]: [, output.headers[_xari]],
+    [_LC]: [, output.headers[_xatlc]],
+    [_MSRH]: [() => void 0 !== output.headers[_xatsr], () => (0, import_smithy_client.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], () => (0, import_smithy_client.parseBoolean)(output.headers[_xatssl])],
+    [_SI]: [, output.headers[_xatsi]],
+    [_ECI]: [() => void 0 !== output.headers[_xateci], () => (0, import_smithy_client.parseBoolean)(output.headers[_xateci])],
+    [_NOC]: [() => void 0 !== output.headers[_xatnoc], () => (0, import_smithy_client.strictParseInt32)(output.headers[_xatnoc])],
+    [_CIT]: [, output.headers[_xatcit]]
+  });
+  const data = output.body;
+  contents.TranscriptResultStream = de_MedicalTranscriptResultStream(data, context);
+  return contents;
+}, "de_StartMedicalStreamTranscriptionCommand");
+var de_StartMedicalStreamTranscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribestreaming#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribestreaming#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribestreaming#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribestreaming#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.transcribestreaming#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartMedicalStreamTranscriptionCommandError");
+var de_StartStreamTranscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartStreamTranscriptionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_RI]: [, output.headers[_xari]],
+    [_LC]: [, output.headers[_xatlc]],
+    [_MSRH]: [() => void 0 !== output.headers[_xatsr], () => (0, import_smithy_client.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], () => (0, import_smithy_client.parseBoolean)(output.headers[_xatssl])],
+    [_ECI]: [() => void 0 !== output.headers[_xateci], () => (0, import_smithy_client.parseBoolean)(output.headers[_xateci])],
+    [_NOC]: [() => void 0 !== output.headers[_xatnoc], () => (0, import_smithy_client.strictParseInt32)(output.headers[_xatnoc])],
+    [_EPRS]: [() => void 0 !== output.headers[_xateprs], () => (0, import_smithy_client.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], () => (0, import_smithy_client.parseBoolean)(output.headers[_xatil])],
+    [_LO]: [, output.headers[_xatlo]],
+    [_PL]: [, output.headers[_xatpl]],
+    [_IML]: [() => void 0 !== output.headers[_xatiml], () => (0, import_smithy_client.parseBoolean)(output.headers[_xatiml])],
+    [_VNo]: [, output.headers[_xatvn_]],
+    [_VFNo]: [, output.headers[_xatvfn_]]
+  });
+  const data = output.body;
+  contents.TranscriptResultStream = de_TranscriptResultStream(data, context);
+  return contents;
+}, "de_StartStreamTranscriptionCommand");
+var de_StartStreamTranscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.transcribestreaming#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribestreaming#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalFailureException":
+    case "com.amazonaws.transcribestreaming#InternalFailureException":
+      throw await de_InternalFailureExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.transcribestreaming#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.transcribestreaming#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartStreamTranscriptionCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(TranscribeStreamingServiceException);
+var de_BadRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new BadRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_BadRequestExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+var de_InternalFailureExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalFailureException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalFailureExceptionRes");
+var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new LimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_LimitExceededExceptionRes");
+var de_ServiceUnavailableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceUnavailableException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceUnavailableExceptionRes");
+var se_AudioStream = /* @__PURE__ */ __name((input, context) => {
+  const eventMarshallingVisitor = /* @__PURE__ */ __name((event) => AudioStream.visit(event, {
+    AudioEvent: (value) => se_AudioEvent_event(value, context),
+    ConfigurationEvent: (value) => se_ConfigurationEvent_event(value, context),
+    _: (value) => value
+  }), "eventMarshallingVisitor");
+  return context.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
+}, "se_AudioStream");
+var se_AudioEvent_event = /* @__PURE__ */ __name((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 };
+}, "se_AudioEvent_event");
+var se_ConfigurationEvent_event = /* @__PURE__ */ __name((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 = (0, import_smithy_client._json)(input);
+  body = context.utf8Decoder(JSON.stringify(body));
+  return { headers, body };
+}, "se_ConfigurationEvent_event");
+var de_CallAnalyticsTranscriptResultStream = /* @__PURE__ */ __name((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: output };
+  });
+}, "de_CallAnalyticsTranscriptResultStream");
+var de_MedicalTranscriptResultStream = /* @__PURE__ */ __name((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: output };
+  });
+}, "de_MedicalTranscriptResultStream");
+var de_TranscriptResultStream = /* @__PURE__ */ __name((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: output };
+  });
+}, "de_TranscriptResultStream");
+var de_BadRequestException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseBody(output.body, context)
+  };
+  return de_BadRequestExceptionRes(parsedOutput, context);
+}, "de_BadRequestException_event");
+var de_CategoryEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await parseBody(output.body, context);
+  Object.assign(contents, (0, import_smithy_client._json)(data));
+  return contents;
+}, "de_CategoryEvent_event");
+var de_ConflictException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseBody(output.body, context)
+  };
+  return de_ConflictExceptionRes(parsedOutput, context);
+}, "de_ConflictException_event");
+var de_InternalFailureException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseBody(output.body, context)
+  };
+  return de_InternalFailureExceptionRes(parsedOutput, context);
+}, "de_InternalFailureException_event");
+var de_LimitExceededException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseBody(output.body, context)
+  };
+  return de_LimitExceededExceptionRes(parsedOutput, context);
+}, "de_LimitExceededException_event");
+var de_MedicalTranscriptEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await parseBody(output.body, context);
+  Object.assign(contents, de_MedicalTranscriptEvent(data, context));
+  return contents;
+}, "de_MedicalTranscriptEvent_event");
+var de_ServiceUnavailableException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseBody(output.body, context)
+  };
+  return de_ServiceUnavailableExceptionRes(parsedOutput, context);
+}, "de_ServiceUnavailableException_event");
+var de_TranscriptEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await parseBody(output.body, context);
+  Object.assign(contents, de_TranscriptEvent(data, context));
+  return contents;
+}, "de_TranscriptEvent_event");
+var de_UtteranceEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await parseBody(output.body, context);
+  Object.assign(contents, de_UtteranceEvent(data, context));
+  return contents;
+}, "de_UtteranceEvent_event");
+var de_Alternative = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Entities: (_) => de_EntityList(_, context),
+    Items: (_) => de_ItemList(_, context),
+    Transcript: import_smithy_client.expectString
+  });
+}, "de_Alternative");
+var de_AlternativeList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Alternative(entry, context);
+  });
+  return retVal;
+}, "de_AlternativeList");
+var de_CallAnalyticsEntity = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BeginOffsetMillis: import_smithy_client.expectLong,
+    Category: import_smithy_client.expectString,
+    Confidence: import_smithy_client.limitedParseDouble,
+    Content: import_smithy_client.expectString,
+    EndOffsetMillis: import_smithy_client.expectLong,
+    Type: import_smithy_client.expectString
+  });
+}, "de_CallAnalyticsEntity");
+var de_CallAnalyticsEntityList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_CallAnalyticsEntity(entry, context);
+  });
+  return retVal;
+}, "de_CallAnalyticsEntityList");
+var de_CallAnalyticsItem = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BeginOffsetMillis: import_smithy_client.expectLong,
+    Confidence: import_smithy_client.limitedParseDouble,
+    Content: import_smithy_client.expectString,
+    EndOffsetMillis: import_smithy_client.expectLong,
+    Stable: import_smithy_client.expectBoolean,
+    Type: import_smithy_client.expectString,
+    VocabularyFilterMatch: import_smithy_client.expectBoolean
+  });
+}, "de_CallAnalyticsItem");
+var de_CallAnalyticsItemList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_CallAnalyticsItem(entry, context);
+  });
+  return retVal;
+}, "de_CallAnalyticsItemList");
+var de_Entity = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Category: import_smithy_client.expectString,
+    Confidence: import_smithy_client.limitedParseDouble,
+    Content: import_smithy_client.expectString,
+    EndTime: import_smithy_client.limitedParseDouble,
+    StartTime: import_smithy_client.limitedParseDouble,
+    Type: import_smithy_client.expectString
+  });
+}, "de_Entity");
+var de_EntityList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Entity(entry, context);
+  });
+  return retVal;
+}, "de_EntityList");
+var de_Item = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Confidence: import_smithy_client.limitedParseDouble,
+    Content: import_smithy_client.expectString,
+    EndTime: import_smithy_client.limitedParseDouble,
+    Speaker: import_smithy_client.expectString,
+    Stable: import_smithy_client.expectBoolean,
+    StartTime: import_smithy_client.limitedParseDouble,
+    Type: import_smithy_client.expectString,
+    VocabularyFilterMatch: import_smithy_client.expectBoolean
+  });
+}, "de_Item");
+var de_ItemList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Item(entry, context);
+  });
+  return retVal;
+}, "de_ItemList");
+var de_LanguageIdentification = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LanguageWithScore(entry, context);
+  });
+  return retVal;
+}, "de_LanguageIdentification");
+var de_LanguageWithScore = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LanguageCode: import_smithy_client.expectString,
+    Score: import_smithy_client.limitedParseDouble
+  });
+}, "de_LanguageWithScore");
+var de_MedicalAlternative = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Entities: (_) => de_MedicalEntityList(_, context),
+    Items: (_) => de_MedicalItemList(_, context),
+    Transcript: import_smithy_client.expectString
+  });
+}, "de_MedicalAlternative");
+var de_MedicalAlternativeList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_MedicalAlternative(entry, context);
+  });
+  return retVal;
+}, "de_MedicalAlternativeList");
+var de_MedicalEntity = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Category: import_smithy_client.expectString,
+    Confidence: import_smithy_client.limitedParseDouble,
+    Content: import_smithy_client.expectString,
+    EndTime: import_smithy_client.limitedParseDouble,
+    StartTime: import_smithy_client.limitedParseDouble
+  });
+}, "de_MedicalEntity");
+var de_MedicalEntityList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_MedicalEntity(entry, context);
+  });
+  return retVal;
+}, "de_MedicalEntityList");
+var de_MedicalItem = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Confidence: import_smithy_client.limitedParseDouble,
+    Content: import_smithy_client.expectString,
+    EndTime: import_smithy_client.limitedParseDouble,
+    Speaker: import_smithy_client.expectString,
+    StartTime: import_smithy_client.limitedParseDouble,
+    Type: import_smithy_client.expectString
+  });
+}, "de_MedicalItem");
+var de_MedicalItemList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_MedicalItem(entry, context);
+  });
+  return retVal;
+}, "de_MedicalItemList");
+var de_MedicalResult = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Alternatives: (_) => de_MedicalAlternativeList(_, context),
+    ChannelId: import_smithy_client.expectString,
+    EndTime: import_smithy_client.limitedParseDouble,
+    IsPartial: import_smithy_client.expectBoolean,
+    ResultId: import_smithy_client.expectString,
+    StartTime: import_smithy_client.limitedParseDouble
+  });
+}, "de_MedicalResult");
+var de_MedicalResultList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_MedicalResult(entry, context);
+  });
+  return retVal;
+}, "de_MedicalResultList");
+var de_MedicalTranscript = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Results: (_) => de_MedicalResultList(_, context)
+  });
+}, "de_MedicalTranscript");
+var de_MedicalTranscriptEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Transcript: (_) => de_MedicalTranscript(_, context)
+  });
+}, "de_MedicalTranscriptEvent");
+var de_Result = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Alternatives: (_) => de_AlternativeList(_, context),
+    ChannelId: import_smithy_client.expectString,
+    EndTime: import_smithy_client.limitedParseDouble,
+    IsPartial: import_smithy_client.expectBoolean,
+    LanguageCode: import_smithy_client.expectString,
+    LanguageIdentification: (_) => de_LanguageIdentification(_, context),
+    ResultId: import_smithy_client.expectString,
+    StartTime: import_smithy_client.limitedParseDouble
+  });
+}, "de_Result");
+var de_ResultList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Result(entry, context);
+  });
+  return retVal;
+}, "de_ResultList");
+var de_Transcript = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Results: (_) => de_ResultList(_, context)
+  });
+}, "de_Transcript");
+var de_TranscriptEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Transcript: (_) => de_Transcript(_, context)
+  });
+}, "de_TranscriptEvent");
+var de_UtteranceEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BeginOffsetMillis: import_smithy_client.expectLong,
+    EndOffsetMillis: import_smithy_client.expectLong,
+    Entities: (_) => de_CallAnalyticsEntityList(_, context),
+    IsPartial: import_smithy_client.expectBoolean,
+    IssuesDetected: import_smithy_client._json,
+    Items: (_) => de_CallAnalyticsItemList(_, context),
+    ParticipantRole: import_smithy_client.expectString,
+    Sentiment: import_smithy_client.expectString,
+    Transcript: import_smithy_client.expectString,
+    UtteranceId: import_smithy_client.expectString
+  });
+}, "de_UtteranceEvent");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var isSerializableHeaderValue = /* @__PURE__ */ __name((value) => value !== void 0 && value !== null && value !== "" && (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) && (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0), "isSerializableHeaderValue");
+var _CIT = "ContentIdentificationType";
+var _CRT = "ContentRedactionType";
+var _ECI = "EnableChannelIdentification";
+var _EPRS = "EnablePartialResultsStabilization";
+var _IL = "IdentifyLanguage";
+var _IML = "IdentifyMultipleLanguages";
+var _LC = "LanguageCode";
+var _LMN = "LanguageModelName";
+var _LO = "LanguageOptions";
+var _ME = "MediaEncoding";
+var _MSRH = "MediaSampleRateHertz";
+var _NOC = "NumberOfChannels";
+var _PET = "PiiEntityTypes";
+var _PL = "PreferredLanguage";
+var _PRS = "PartialResultsStability";
+var _RI = "RequestId";
+var _S = "Specialty";
+var _SI = "SessionId";
+var _SSL = "ShowSpeakerLabel";
+var _T = "Type";
+var _VFM = "VocabularyFilterMethod";
+var _VFN = "VocabularyFilterName";
+var _VFNo = "VocabularyFilterNames";
+var _VN = "VocabularyName";
+var _VNo = "VocabularyNames";
+var _xari = "x-amzn-request-id";
+var _xatcit = "x-amzn-transcribe-content-identification-type";
+var _xatcrt = "x-amzn-transcribe-content-redaction-type";
+var _xateci = "x-amzn-transcribe-enable-channel-identification";
+var _xateprs = "x-amzn-transcribe-enable-partial-results-stabilization";
+var _xatil = "x-amzn-transcribe-identify-language";
+var _xatiml = "x-amzn-transcribe-identify-multiple-languages";
+var _xatlc = "x-amzn-transcribe-language-code";
+var _xatlmn = "x-amzn-transcribe-language-model-name";
+var _xatlo = "x-amzn-transcribe-language-options";
+var _xatme = "x-amzn-transcribe-media-encoding";
+var _xatnoc = "x-amzn-transcribe-number-of-channels";
+var _xatpet = "x-amzn-transcribe-pii-entity-types";
+var _xatpl = "x-amzn-transcribe-preferred-language";
+var _xatprs = "x-amzn-transcribe-partial-results-stability";
+var _xats = "x-amzn-transcribe-specialty";
+var _xatsi = "x-amzn-transcribe-session-id";
+var _xatsr = "x-amzn-transcribe-sample-rate";
+var _xatssl = "x-amzn-transcribe-show-speaker-label";
+var _xatt = "x-amzn-transcribe-type";
+var _xatvfm = "x-amzn-transcribe-vocabulary-filter-method";
+var _xatvfn = "x-amzn-transcribe-vocabulary-filter-name";
+var _xatvfn_ = "x-amzn-transcribe-vocabulary-filter-names";
+var _xatvn = "x-amzn-transcribe-vocabulary-name";
+var _xatvn_ = "x-amzn-transcribe-vocabulary-names";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/StartCallAnalyticsStreamTranscriptionCommand.ts
+var _StartCallAnalyticsStreamTranscriptionCommand = class _StartCallAnalyticsStreamTranscriptionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()),
+    (0, import_middleware_eventstream.getEventStreamPlugin)(config),
+    (0, import_middleware_websocket.getWebSocketPlugin)(config, { headerPrefix: "x-amzn-transcribe-" })
+  ];
+}).s("Transcribe", "StartCallAnalyticsStreamTranscription", {
+  /**
+   * @internal
+   */
+  eventStream: {
+    input: true,
+    output: true
+  }
+}).n("TranscribeStreamingClient", "StartCallAnalyticsStreamTranscriptionCommand").f(
+  StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog,
+  StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog
+).ser(se_StartCallAnalyticsStreamTranscriptionCommand).de(de_StartCallAnalyticsStreamTranscriptionCommand).build() {
+};
+__name(_StartCallAnalyticsStreamTranscriptionCommand, "StartCallAnalyticsStreamTranscriptionCommand");
+var StartCallAnalyticsStreamTranscriptionCommand = _StartCallAnalyticsStreamTranscriptionCommand;
+
+// src/commands/StartMedicalStreamTranscriptionCommand.ts
+
+
+
+
+
+
+var _StartMedicalStreamTranscriptionCommand = class _StartMedicalStreamTranscriptionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()),
+    (0, import_middleware_eventstream.getEventStreamPlugin)(config),
+    (0, import_middleware_websocket.getWebSocketPlugin)(config, { headerPrefix: "x-amzn-transcribe-" })
+  ];
+}).s("Transcribe", "StartMedicalStreamTranscription", {
+  /**
+   * @internal
+   */
+  eventStream: {
+    input: true,
+    output: true
+  }
+}).n("TranscribeStreamingClient", "StartMedicalStreamTranscriptionCommand").f(
+  StartMedicalStreamTranscriptionRequestFilterSensitiveLog,
+  StartMedicalStreamTranscriptionResponseFilterSensitiveLog
+).ser(se_StartMedicalStreamTranscriptionCommand).de(de_StartMedicalStreamTranscriptionCommand).build() {
+};
+__name(_StartMedicalStreamTranscriptionCommand, "StartMedicalStreamTranscriptionCommand");
+var StartMedicalStreamTranscriptionCommand = _StartMedicalStreamTranscriptionCommand;
+
+// src/commands/StartStreamTranscriptionCommand.ts
+
+
+
+
+
+
+var _StartStreamTranscriptionCommand = class _StartStreamTranscriptionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()),
+    (0, import_middleware_eventstream.getEventStreamPlugin)(config),
+    (0, import_middleware_websocket.getWebSocketPlugin)(config, { headerPrefix: "x-amzn-transcribe-" })
+  ];
+}).s("Transcribe", "StartStreamTranscription", {
+  /**
+   * @internal
+   */
+  eventStream: {
+    input: true,
+    output: true
+  }
+}).n("TranscribeStreamingClient", "StartStreamTranscriptionCommand").f(StartStreamTranscriptionRequestFilterSensitiveLog, StartStreamTranscriptionResponseFilterSensitiveLog).ser(se_StartStreamTranscriptionCommand).de(de_StartStreamTranscriptionCommand).build() {
+};
+__name(_StartStreamTranscriptionCommand, "StartStreamTranscriptionCommand");
+var StartStreamTranscriptionCommand = _StartStreamTranscriptionCommand;
+
+// src/TranscribeStreaming.ts
+var commands = {
+  StartCallAnalyticsStreamTranscriptionCommand,
+  StartMedicalStreamTranscriptionCommand,
+  StartStreamTranscriptionCommand
+};
+var _TranscribeStreaming = class _TranscribeStreaming extends TranscribeStreamingClient {
+};
+__name(_TranscribeStreaming, "TranscribeStreaming");
+var TranscribeStreaming = _TranscribeStreaming;
+(0, import_smithy_client.createAggregatedClient)(commands, TranscribeStreaming);
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AudioStream,
+  AudioStreamFilterSensitiveLog,
+  BadRequestException,
+  CallAnalyticsLanguageCode,
+  CallAnalyticsTranscriptResultStream,
+  CallAnalyticsTranscriptResultStreamFilterSensitiveLog,
+  ConflictException,
+  ContentIdentificationType,
+  ContentRedactionOutput,
+  ContentRedactionType,
+  InternalFailureException,
+  ItemType,
+  LanguageCode,
+  LimitExceededException,
+  MediaEncoding,
+  MedicalContentIdentificationType,
+  MedicalTranscriptResultStream,
+  MedicalTranscriptResultStreamFilterSensitiveLog,
+  PartialResultsStability,
+  ParticipantRole,
+  Sentiment,
+  ServiceUnavailableException,
+  Specialty,
+  StartCallAnalyticsStreamTranscriptionCommand,
+  StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog,
+  StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog,
+  StartMedicalStreamTranscriptionCommand,
+  StartMedicalStreamTranscriptionRequestFilterSensitiveLog,
+  StartMedicalStreamTranscriptionResponseFilterSensitiveLog,
+  StartStreamTranscriptionCommand,
+  StartStreamTranscriptionRequestFilterSensitiveLog,
+  StartStreamTranscriptionResponseFilterSensitiveLog,
+  TranscribeStreaming,
+  TranscribeStreamingClient,
+  TranscribeStreamingServiceException,
+  TranscriptResultStream,
+  TranscriptResultStreamFilterSensitiveLog,
+  Type,
+  VocabularyFilterMethod,
+  __Client
+});