@aws-sdk/client-transcribe-streaming 3.734.0 → 3.741.0

package/dist-cjs/index.js

@@ -27,26 +27,43 @@ __export(src_exports, {
   CallAnalyticsLanguageCode: () => CallAnalyticsLanguageCode,
   CallAnalyticsTranscriptResultStream: () => CallAnalyticsTranscriptResultStream,
   CallAnalyticsTranscriptResultStreamFilterSensitiveLog: () => CallAnalyticsTranscriptResultStreamFilterSensitiveLog,
+  ClinicalNoteGenerationStatus: () => ClinicalNoteGenerationStatus,
   ConflictException: () => ConflictException,
   ContentIdentificationType: () => ContentIdentificationType,
   ContentRedactionOutput: () => ContentRedactionOutput,
   ContentRedactionType: () => ContentRedactionType,
+  GetMedicalScribeStreamCommand: () => GetMedicalScribeStreamCommand,
   InternalFailureException: () => InternalFailureException,
   ItemType: () => ItemType,
   LanguageCode: () => LanguageCode,
   LimitExceededException: () => LimitExceededException,
   MediaEncoding: () => MediaEncoding,
   MedicalContentIdentificationType: () => MedicalContentIdentificationType,
+  MedicalScribeInputStream: () => MedicalScribeInputStream,
+  MedicalScribeInputStreamFilterSensitiveLog: () => MedicalScribeInputStreamFilterSensitiveLog,
+  MedicalScribeLanguageCode: () => MedicalScribeLanguageCode,
+  MedicalScribeMediaEncoding: () => MedicalScribeMediaEncoding,
+  MedicalScribeParticipantRole: () => MedicalScribeParticipantRole,
+  MedicalScribeResultStream: () => MedicalScribeResultStream,
+  MedicalScribeResultStreamFilterSensitiveLog: () => MedicalScribeResultStreamFilterSensitiveLog,
+  MedicalScribeSessionControlEventType: () => MedicalScribeSessionControlEventType,
+  MedicalScribeStreamStatus: () => MedicalScribeStreamStatus,
+  MedicalScribeTranscriptItemType: () => MedicalScribeTranscriptItemType,
+  MedicalScribeVocabularyFilterMethod: () => MedicalScribeVocabularyFilterMethod,
   MedicalTranscriptResultStream: () => MedicalTranscriptResultStream,
   MedicalTranscriptResultStreamFilterSensitiveLog: () => MedicalTranscriptResultStreamFilterSensitiveLog,
   PartialResultsStability: () => PartialResultsStability,
   ParticipantRole: () => ParticipantRole,
+  ResourceNotFoundException: () => ResourceNotFoundException,
   Sentiment: () => Sentiment,
   ServiceUnavailableException: () => ServiceUnavailableException,
   Specialty: () => Specialty,
   StartCallAnalyticsStreamTranscriptionCommand: () => StartCallAnalyticsStreamTranscriptionCommand,
   StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog: () => StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog,
   StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog: () => StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog,
+  StartMedicalScribeStreamCommand: () => StartMedicalScribeStreamCommand,
+  StartMedicalScribeStreamRequestFilterSensitiveLog: () => StartMedicalScribeStreamRequestFilterSensitiveLog,
+  StartMedicalScribeStreamResponseFilterSensitiveLog: () => StartMedicalScribeStreamResponseFilterSensitiveLog,
   StartMedicalStreamTranscriptionCommand: () => StartMedicalStreamTranscriptionCommand,
   StartMedicalStreamTranscriptionRequestFilterSensitiveLog: () => StartMedicalStreamTranscriptionRequestFilterSensitiveLog,
   StartMedicalStreamTranscriptionResponseFilterSensitiveLog: () => StartMedicalStreamTranscriptionResponseFilterSensitiveLog,
@@ -215,12 +232,14 @@ var TranscribeStreamingClient = class extends import_smithy_client.Client {
 // src/TranscribeStreaming.ts
 
 
-// src/commands/StartCallAnalyticsStreamTranscriptionCommand.ts
+// src/commands/GetMedicalScribeStreamCommand.ts
 
-var import_middleware_sdk_transcribe_streaming = require("@aws-sdk/middleware-sdk-transcribe-streaming");
+var import_middleware_serde = require("@smithy/middleware-serde");
 
 
-var import_middleware_serde = require("@smithy/middleware-serde");
+// src/protocols/Aws_restJson1.ts
+var import_core2 = require("@aws-sdk/core");
+
 
 
 // src/models/TranscribeStreamingServiceException.ts
@@ -398,12 +417,60 @@ var CallAnalyticsTranscriptResultStream;
     return visitor._(value.$unknown[0], value.$unknown[1]);
   }, "visit");
 })(CallAnalyticsTranscriptResultStream || (CallAnalyticsTranscriptResultStream = {}));
+var ClinicalNoteGenerationStatus = {
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS"
+};
 var ContentIdentificationType = {
   PII: "PII"
 };
 var ContentRedactionType = {
   PII: "PII"
 };
+var MedicalScribeParticipantRole = {
+  CLINICIAN: "CLINICIAN",
+  PATIENT: "PATIENT"
+};
+var MedicalScribeLanguageCode = {
+  EN_US: "en-US"
+};
+var MedicalScribeMediaEncoding = {
+  FLAC: "flac",
+  OGG_OPUS: "ogg-opus",
+  PCM: "pcm"
+};
+var MedicalScribeStreamStatus = {
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS",
+  PAUSED: "PAUSED"
+};
+var MedicalScribeVocabularyFilterMethod = {
+  MASK: "mask",
+  REMOVE: "remove",
+  TAG: "tag"
+};
+var ResourceNotFoundException = class _ResourceNotFoundException extends TranscribeStreamingServiceException {
+  static {
+    __name(this, "ResourceNotFoundException");
+  }
+  name = "ResourceNotFoundException";
+  $fault = "client";
+  Message;
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
 var LanguageCode = {
   AF_ZA: "af-ZA",
   AR_AE: "ar-AE",
@@ -468,6 +535,43 @@ var MediaEncoding = {
 var MedicalContentIdentificationType = {
   PHI: "PHI"
 };
+var MedicalScribeSessionControlEventType = {
+  END_OF_SESSION: "END_OF_SESSION"
+};
+var MedicalScribeInputStream;
+((MedicalScribeInputStream2) => {
+  MedicalScribeInputStream2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.AudioEvent !== void 0)
+      return visitor.AudioEvent(value.AudioEvent);
+    if (value.SessionControlEvent !== void 0)
+      return visitor.SessionControlEvent(value.SessionControlEvent);
+    if (value.ConfigurationEvent !== void 0)
+      return visitor.ConfigurationEvent(value.ConfigurationEvent);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(MedicalScribeInputStream || (MedicalScribeInputStream = {}));
+var MedicalScribeTranscriptItemType = {
+  PRONUNCIATION: "pronunciation",
+  PUNCTUATION: "punctuation"
+};
+var MedicalScribeResultStream;
+((MedicalScribeResultStream3) => {
+  MedicalScribeResultStream3.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");
+})(MedicalScribeResultStream || (MedicalScribeResultStream = {}));
 var MedicalTranscriptResultStream;
 ((MedicalTranscriptResultStream3) => {
   MedicalTranscriptResultStream3.visit = /* @__PURE__ */ __name((value, visitor) => {
@@ -552,6 +656,32 @@ var CallAnalyticsTranscriptResultStreamFilterSensitiveLog = /* @__PURE__ */ __na
   if (obj.$unknown !== void 0)
     return { [obj.$unknown[0]]: "UNKNOWN" };
 }, "CallAnalyticsTranscriptResultStreamFilterSensitiveLog");
+var MedicalScribeInputStreamFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.AudioEvent !== void 0)
+    return { AudioEvent: obj.AudioEvent };
+  if (obj.SessionControlEvent !== void 0)
+    return { SessionControlEvent: obj.SessionControlEvent };
+  if (obj.ConfigurationEvent !== void 0)
+    return { ConfigurationEvent: obj.ConfigurationEvent };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "MedicalScribeInputStreamFilterSensitiveLog");
+var MedicalScribeResultStreamFilterSensitiveLog = /* @__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" };
+}, "MedicalScribeResultStreamFilterSensitiveLog");
 var MedicalTranscriptResultStreamFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
   if (obj.TranscriptEvent !== void 0)
     return { TranscriptEvent: obj.TranscriptEvent };
@@ -576,6 +706,14 @@ var StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog = /* @__PURE
   ...obj,
   ...obj.CallAnalyticsTranscriptResultStream && { CallAnalyticsTranscriptResultStream: "STREAMING_CONTENT" }
 }), "StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog");
+var StartMedicalScribeStreamRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.InputStream && { InputStream: "STREAMING_CONTENT" }
+}), "StartMedicalScribeStreamRequestFilterSensitiveLog");
+var StartMedicalScribeStreamResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.ResultStream && { ResultStream: "STREAMING_CONTENT" }
+}), "StartMedicalScribeStreamResponseFilterSensitiveLog");
 var StartMedicalStreamTranscriptionRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj,
   ...obj.AudioStream && { AudioStream: "STREAMING_CONTENT" }
@@ -610,9 +748,15 @@ var StartStreamTranscriptionResponseFilterSensitiveLog = /* @__PURE__ */ __name(
 }), "StartStreamTranscriptionResponseFilterSensitiveLog");
 
 // src/protocols/Aws_restJson1.ts
-var import_core2 = require("@aws-sdk/core");
-
-
+var se_GetMedicalScribeStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_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();
+}, "se_GetMedicalScribeStreamCommand");
 var se_StartCallAnalyticsStreamTranscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = (0, import_smithy_client.map)({}, import_smithy_client.isSerializableHeaderValue, {
@@ -639,6 +783,23 @@ var se_StartCallAnalyticsStreamTranscriptionCommand = /* @__PURE__ */ __name(asy
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_StartCallAnalyticsStreamTranscriptionCommand");
+var se_StartMedicalScribeStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, import_smithy_client.isSerializableHeaderValue, {
+    "content-type": "application/json",
+    [_xatsi]: input[_SI],
+    [_xatlc]: input[_LC],
+    [_xatsr]: [() => (0, import_smithy_client.isSerializableHeaderValue)(input[_MSRH]), () => input[_MSRH].toString()],
+    [_xatme]: input[_ME]
+  });
+  b.bp("/medical-scribe-stream");
+  let body;
+  if (input.InputStream !== void 0) {
+    body = se_MedicalScribeInputStream(input.InputStream, context);
+  }
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartMedicalScribeStreamCommand");
 var se_StartMedicalStreamTranscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = (0, import_smithy_client.map)({}, import_smithy_client.isSerializableHeaderValue, {
@@ -698,6 +859,20 @@ var se_StartStreamTranscriptionCommand = /* @__PURE__ */ __name(async (input, co
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_StartStreamTranscriptionCommand");
+var de_GetMedicalScribeStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    MedicalScribeStreamDetails: (_) => de_MedicalScribeStreamDetails(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetMedicalScribeStreamCommand");
 var de_StartCallAnalyticsStreamTranscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -723,6 +898,22 @@ var de_StartCallAnalyticsStreamTranscriptionCommand = /* @__PURE__ */ __name(asy
   contents.CallAnalyticsTranscriptResultStream = de_CallAnalyticsTranscriptResultStream(data, context);
   return contents;
 }, "de_StartCallAnalyticsStreamTranscriptionCommand");
+var de_StartMedicalScribeStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output),
+    [_SI]: [, output.headers[_xatsi]],
+    [_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]]
+  });
+  const data = output.body;
+  contents.ResultStream = de_MedicalScribeResultStream(data, context);
+  return contents;
+}, "de_StartMedicalScribeStreamCommand");
 var de_StartMedicalStreamTranscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -790,15 +981,18 @@ var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
     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 "ResourceNotFoundException":
+    case "com.amazonaws.transcribestreaming#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.transcribestreaming#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
     case "ServiceUnavailableException":
     case "com.amazonaws.transcribestreaming#ServiceUnavailableException":
       throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
@@ -864,6 +1058,19 @@ var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, c
   });
   return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
 }, "de_LimitExceededExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__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 ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotFoundExceptionRes");
 var de_ServiceUnavailableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
   const contents = (0, import_smithy_client.map)({});
   const data = parsedOutput.body;
@@ -885,6 +1092,15 @@ var se_AudioStream = /* @__PURE__ */ __name((input, context) => {
   }), "eventMarshallingVisitor");
   return context.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
 }, "se_AudioStream");
+var se_MedicalScribeInputStream = /* @__PURE__ */ __name((input, context) => {
+  const eventMarshallingVisitor = /* @__PURE__ */ __name((event) => MedicalScribeInputStream.visit(event, {
+    AudioEvent: (value) => se_MedicalScribeAudioEvent_event(value, context),
+    SessionControlEvent: (value) => se_MedicalScribeSessionControlEvent_event(value, context),
+    ConfigurationEvent: (value) => se_MedicalScribeConfigurationEvent_event(value, context),
+    _: (value) => value
+  }), "eventMarshallingVisitor");
+  return context.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
+}, "se_MedicalScribeInputStream");
 var se_AudioEvent_event = /* @__PURE__ */ __name((input, context) => {
   const headers = {
     ":event-type": { type: "string", value: "AudioEvent" },
@@ -908,6 +1124,40 @@ var se_ConfigurationEvent_event = /* @__PURE__ */ __name((input, context) => {
   body = context.utf8Decoder(JSON.stringify(body));
   return { headers, body };
 }, "se_ConfigurationEvent_event");
+var se_MedicalScribeAudioEvent_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_MedicalScribeAudioEvent_event");
+var se_MedicalScribeConfigurationEvent_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_MedicalScribeConfigurationEvent_event");
+var se_MedicalScribeSessionControlEvent_event = /* @__PURE__ */ __name((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 = (0, import_smithy_client._json)(input);
+  body = context.utf8Decoder(JSON.stringify(body));
+  return { headers, body };
+}, "se_MedicalScribeSessionControlEvent_event");
 var de_CallAnalyticsTranscriptResultStream = /* @__PURE__ */ __name((output, context) => {
   return context.eventStreamMarshaller.deserialize(output, async (event) => {
     if (event["UtteranceEvent"] != null) {
@@ -951,6 +1201,44 @@ var de_CallAnalyticsTranscriptResultStream = /* @__PURE__ */ __name((output, con
     return { $unknown: output };
   });
 }, "de_CallAnalyticsTranscriptResultStream");
+var de_MedicalScribeResultStream = /* @__PURE__ */ __name((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: output };
+  });
+}, "de_MedicalScribeResultStream");
 var de_MedicalTranscriptResultStream = /* @__PURE__ */ __name((output, context) => {
   return context.eventStreamMarshaller.deserialize(output, async (event) => {
     if (event["TranscriptEvent"] != null) {
@@ -1061,6 +1349,12 @@ var de_LimitExceededException_event = /* @__PURE__ */ __name(async (output, cont
   };
   return de_LimitExceededExceptionRes(parsedOutput, context);
 }, "de_LimitExceededException_event");
+var de_MedicalScribeTranscriptEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  Object.assign(contents, de_MedicalScribeTranscriptEvent(data, context));
+  return contents;
+}, "de_MedicalScribeTranscriptEvent_event");
 var de_MedicalTranscriptEvent_event = /* @__PURE__ */ __name(async (output, context) => {
   const contents = {};
   const data = await (0, import_core2.parseJsonBody)(output.body, context);
@@ -1238,6 +1532,57 @@ var de_MedicalResultList = /* @__PURE__ */ __name((output, context) => {
   });
   return retVal;
 }, "de_MedicalResultList");
+var de_MedicalScribeStreamDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ChannelDefinitions: import_smithy_client._json,
+    EncryptionSettings: import_smithy_client._json,
+    LanguageCode: import_smithy_client.expectString,
+    MediaEncoding: import_smithy_client.expectString,
+    MediaSampleRateHertz: import_smithy_client.expectInt32,
+    PostStreamAnalyticsResult: import_smithy_client._json,
+    PostStreamAnalyticsSettings: import_smithy_client._json,
+    ResourceAccessRoleArn: import_smithy_client.expectString,
+    SessionId: import_smithy_client.expectString,
+    StreamCreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    StreamEndedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    StreamStatus: import_smithy_client.expectString,
+    VocabularyFilterMethod: import_smithy_client.expectString,
+    VocabularyFilterName: import_smithy_client.expectString,
+    VocabularyName: import_smithy_client.expectString
+  });
+}, "de_MedicalScribeStreamDetails");
+var de_MedicalScribeTranscriptEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    TranscriptSegment: (_) => de_MedicalScribeTranscriptSegment(_, context)
+  });
+}, "de_MedicalScribeTranscriptEvent");
+var de_MedicalScribeTranscriptItem = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BeginAudioTime: import_smithy_client.limitedParseDouble,
+    Confidence: import_smithy_client.limitedParseDouble,
+    Content: import_smithy_client.expectString,
+    EndAudioTime: import_smithy_client.limitedParseDouble,
+    Type: import_smithy_client.expectString,
+    VocabularyFilterMatch: import_smithy_client.expectBoolean
+  });
+}, "de_MedicalScribeTranscriptItem");
+var de_MedicalScribeTranscriptItemList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_MedicalScribeTranscriptItem(entry, context);
+  });
+  return retVal;
+}, "de_MedicalScribeTranscriptItemList");
+var de_MedicalScribeTranscriptSegment = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BeginAudioTime: import_smithy_client.limitedParseDouble,
+    ChannelId: import_smithy_client.expectString,
+    Content: import_smithy_client.expectString,
+    EndAudioTime: import_smithy_client.limitedParseDouble,
+    IsPartial: import_smithy_client.expectBoolean,
+    Items: (_) => de_MedicalScribeTranscriptItemList(_, context),
+    SegmentId: import_smithy_client.expectString
+  });
+}, "de_MedicalScribeTranscriptSegment");
 var de_MedicalTranscript = /* @__PURE__ */ __name((output, context) => {
   return (0, import_smithy_client.take)(output, {
     Results: (_) => de_MedicalResultList(_, context)
@@ -1347,7 +1692,25 @@ var _xatvfn_ = "x-amzn-transcribe-vocabulary-filter-names";
 var _xatvn = "x-amzn-transcribe-vocabulary-name";
 var _xatvn_ = "x-amzn-transcribe-vocabulary-names";
 
+// src/commands/GetMedicalScribeStreamCommand.ts
+var GetMedicalScribeStreamCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Transcribe", "GetMedicalScribeStream", {}).n("TranscribeStreamingClient", "GetMedicalScribeStreamCommand").f(void 0, void 0).ser(se_GetMedicalScribeStreamCommand).de(de_GetMedicalScribeStreamCommand).build() {
+  static {
+    __name(this, "GetMedicalScribeStreamCommand");
+  }
+};
+
 // src/commands/StartCallAnalyticsStreamTranscriptionCommand.ts
+
+var import_middleware_sdk_transcribe_streaming = require("@aws-sdk/middleware-sdk-transcribe-streaming");
+
+
+
+
 var StartCallAnalyticsStreamTranscriptionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
   return [
     (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
@@ -1375,6 +1738,37 @@ var StartCallAnalyticsStreamTranscriptionCommand = class extends import_smithy_c
   }
 };
 
+// src/commands/StartMedicalScribeStreamCommand.ts
+
+
+
+
+
+
+var StartMedicalScribeStreamCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()),
+    (0, import_middleware_eventstream.getEventStreamPlugin)(config),
+    (0, import_middleware_websocket.getWebSocketPlugin)(config, {
+      headerPrefix: "x-amzn-transcribe-"
+    }),
+    (0, import_middleware_sdk_transcribe_streaming.getTranscribeStreamingPlugin)(config)
+  ];
+}).s("Transcribe", "StartMedicalScribeStream", {
+  /**
+   * @internal
+   */
+  eventStream: {
+    input: true,
+    output: true
+  }
+}).n("TranscribeStreamingClient", "StartMedicalScribeStreamCommand").f(StartMedicalScribeStreamRequestFilterSensitiveLog, StartMedicalScribeStreamResponseFilterSensitiveLog).ser(se_StartMedicalScribeStreamCommand).de(de_StartMedicalScribeStreamCommand).build() {
+  static {
+    __name(this, "StartMedicalScribeStreamCommand");
+  }
+};
+
 // src/commands/StartMedicalStreamTranscriptionCommand.ts
 
 
@@ -1442,7 +1836,9 @@ var StartStreamTranscriptionCommand = class extends import_smithy_client.Command
 
 // src/TranscribeStreaming.ts
 var commands = {
+  GetMedicalScribeStreamCommand,
   StartCallAnalyticsStreamTranscriptionCommand,
+  StartMedicalScribeStreamCommand,
   StartMedicalStreamTranscriptionCommand,
   StartStreamTranscriptionCommand
 };
@@ -1460,7 +1856,9 @@ var TranscribeStreaming = class extends TranscribeStreamingClient {
   TranscribeStreamingClient,
   TranscribeStreaming,
   $Command,
+  GetMedicalScribeStreamCommand,
   StartCallAnalyticsStreamTranscriptionCommand,
+  StartMedicalScribeStreamCommand,
   StartMedicalStreamTranscriptionCommand,
   StartStreamTranscriptionCommand,
   ItemType,
@@ -1475,11 +1873,22 @@ var TranscribeStreaming = class extends TranscribeStreamingClient {
   ServiceUnavailableException,
   Sentiment,
   CallAnalyticsTranscriptResultStream,
+  ClinicalNoteGenerationStatus,
   ContentIdentificationType,
   ContentRedactionType,
+  MedicalScribeParticipantRole,
+  MedicalScribeLanguageCode,
+  MedicalScribeMediaEncoding,
+  MedicalScribeStreamStatus,
+  MedicalScribeVocabularyFilterMethod,
+  ResourceNotFoundException,
   LanguageCode,
   MediaEncoding,
   MedicalContentIdentificationType,
+  MedicalScribeSessionControlEventType,
+  MedicalScribeInputStream,
+  MedicalScribeTranscriptItemType,
+  MedicalScribeResultStream,
   MedicalTranscriptResultStream,
   PartialResultsStability,
   Specialty,
@@ -1488,9 +1897,13 @@ var TranscribeStreaming = class extends TranscribeStreamingClient {
   TranscriptResultStream,
   AudioStreamFilterSensitiveLog,
   CallAnalyticsTranscriptResultStreamFilterSensitiveLog,
+  MedicalScribeInputStreamFilterSensitiveLog,
+  MedicalScribeResultStreamFilterSensitiveLog,
   MedicalTranscriptResultStreamFilterSensitiveLog,
   StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog,
   StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog,
+  StartMedicalScribeStreamRequestFilterSensitiveLog,
+  StartMedicalScribeStreamResponseFilterSensitiveLog,
   StartMedicalStreamTranscriptionRequestFilterSensitiveLog,
   StartMedicalStreamTranscriptionResponseFilterSensitiveLog,
   StartStreamTranscriptionRequestFilterSensitiveLog,

package/dist-es/TranscribeStreaming.js

@@ -1,10 +1,14 @@
 import { createAggregatedClient } from "@smithy/smithy-client";
+import { GetMedicalScribeStreamCommand, } from "./commands/GetMedicalScribeStreamCommand";
 import { StartCallAnalyticsStreamTranscriptionCommand, } from "./commands/StartCallAnalyticsStreamTranscriptionCommand";
+import { StartMedicalScribeStreamCommand, } from "./commands/StartMedicalScribeStreamCommand";
 import { StartMedicalStreamTranscriptionCommand, } from "./commands/StartMedicalStreamTranscriptionCommand";
 import { StartStreamTranscriptionCommand, } from "./commands/StartStreamTranscriptionCommand";
 import { TranscribeStreamingClient } from "./TranscribeStreamingClient";
 const commands = {
+    GetMedicalScribeStreamCommand,
     StartCallAnalyticsStreamTranscriptionCommand,
+    StartMedicalScribeStreamCommand,
     StartMedicalStreamTranscriptionCommand,
     StartStreamTranscriptionCommand,
 };

package/dist-es/commands/GetMedicalScribeStreamCommand.js

@@ -0,0 +1,22 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_GetMedicalScribeStreamCommand, se_GetMedicalScribeStreamCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetMedicalScribeStreamCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Transcribe", "GetMedicalScribeStream", {})
+    .n("TranscribeStreamingClient", "GetMedicalScribeStreamCommand")
+    .f(void 0, void 0)
+    .ser(se_GetMedicalScribeStreamCommand)
+    .de(de_GetMedicalScribeStreamCommand)
+    .build() {
+}