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

package/dist-es/commands/StartMedicalScribeStreamCommand.js

@@ -0,0 +1,36 @@
+import { getEventStreamPlugin } from "@aws-sdk/middleware-eventstream";
+import { getTranscribeStreamingPlugin } from "@aws-sdk/middleware-sdk-transcribe-streaming";
+import { getWebSocketPlugin } from "@aws-sdk/middleware-websocket";
+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 { StartMedicalScribeStreamRequestFilterSensitiveLog, StartMedicalScribeStreamResponseFilterSensitiveLog, } from "../models/models_0";
+import { de_StartMedicalScribeStreamCommand, se_StartMedicalScribeStreamCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class StartMedicalScribeStreamCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getEventStreamPlugin(config),
+        getWebSocketPlugin(config, {
+            headerPrefix: "x-amzn-transcribe-",
+        }),
+        getTranscribeStreamingPlugin(config),
+    ];
+})
+    .s("Transcribe", "StartMedicalScribeStream", {
+    eventStream: {
+        input: true,
+        output: true,
+    },
+})
+    .n("TranscribeStreamingClient", "StartMedicalScribeStreamCommand")
+    .f(StartMedicalScribeStreamRequestFilterSensitiveLog, StartMedicalScribeStreamResponseFilterSensitiveLog)
+    .ser(se_StartMedicalScribeStreamCommand)
+    .de(de_StartMedicalScribeStreamCommand)
+    .build() {
+}

package/dist-es/commands/index.js

@@ -1,3 +1,5 @@
+export * from "./GetMedicalScribeStreamCommand";
 export * from "./StartCallAnalyticsStreamTranscriptionCommand";
+export * from "./StartMedicalScribeStreamCommand";
 export * from "./StartMedicalStreamTranscriptionCommand";
 export * from "./StartStreamTranscriptionCommand";

package/dist-es/models/models_0.js

@@ -128,12 +128,54 @@ export var CallAnalyticsTranscriptResultStream;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(CallAnalyticsTranscriptResultStream || (CallAnalyticsTranscriptResultStream = {}));
+export const ClinicalNoteGenerationStatus = {
+    COMPLETED: "COMPLETED",
+    FAILED: "FAILED",
+    IN_PROGRESS: "IN_PROGRESS",
+};
 export const ContentIdentificationType = {
     PII: "PII",
 };
 export const ContentRedactionType = {
     PII: "PII",
 };
+export const MedicalScribeParticipantRole = {
+    CLINICIAN: "CLINICIAN",
+    PATIENT: "PATIENT",
+};
+export const MedicalScribeLanguageCode = {
+    EN_US: "en-US",
+};
+export const MedicalScribeMediaEncoding = {
+    FLAC: "flac",
+    OGG_OPUS: "ogg-opus",
+    PCM: "pcm",
+};
+export const MedicalScribeStreamStatus = {
+    COMPLETED: "COMPLETED",
+    FAILED: "FAILED",
+    IN_PROGRESS: "IN_PROGRESS",
+    PAUSED: "PAUSED",
+};
+export const MedicalScribeVocabularyFilterMethod = {
+    MASK: "mask",
+    REMOVE: "remove",
+    TAG: "tag",
+};
+export class ResourceNotFoundException extends __BaseException {
+    name = "ResourceNotFoundException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.Message = opts.Message;
+    }
+}
 export const LanguageCode = {
     AF_ZA: "af-ZA",
     AR_AE: "ar-AE",
@@ -198,6 +240,43 @@ export const MediaEncoding = {
 export const MedicalContentIdentificationType = {
     PHI: "PHI",
 };
+export const MedicalScribeSessionControlEventType = {
+    END_OF_SESSION: "END_OF_SESSION",
+};
+export var MedicalScribeInputStream;
+(function (MedicalScribeInputStream) {
+    MedicalScribeInputStream.visit = (value, visitor) => {
+        if (value.AudioEvent !== undefined)
+            return visitor.AudioEvent(value.AudioEvent);
+        if (value.SessionControlEvent !== undefined)
+            return visitor.SessionControlEvent(value.SessionControlEvent);
+        if (value.ConfigurationEvent !== undefined)
+            return visitor.ConfigurationEvent(value.ConfigurationEvent);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(MedicalScribeInputStream || (MedicalScribeInputStream = {}));
+export const MedicalScribeTranscriptItemType = {
+    PRONUNCIATION: "pronunciation",
+    PUNCTUATION: "punctuation",
+};
+export var MedicalScribeResultStream;
+(function (MedicalScribeResultStream) {
+    MedicalScribeResultStream.visit = (value, visitor) => {
+        if (value.TranscriptEvent !== undefined)
+            return visitor.TranscriptEvent(value.TranscriptEvent);
+        if (value.BadRequestException !== undefined)
+            return visitor.BadRequestException(value.BadRequestException);
+        if (value.LimitExceededException !== undefined)
+            return visitor.LimitExceededException(value.LimitExceededException);
+        if (value.InternalFailureException !== undefined)
+            return visitor.InternalFailureException(value.InternalFailureException);
+        if (value.ConflictException !== undefined)
+            return visitor.ConflictException(value.ConflictException);
+        if (value.ServiceUnavailableException !== undefined)
+            return visitor.ServiceUnavailableException(value.ServiceUnavailableException);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(MedicalScribeResultStream || (MedicalScribeResultStream = {}));
 export var MedicalTranscriptResultStream;
 (function (MedicalTranscriptResultStream) {
     MedicalTranscriptResultStream.visit = (value, visitor) => {
@@ -282,6 +361,32 @@ export const CallAnalyticsTranscriptResultStreamFilterSensitiveLog = (obj) => {
     if (obj.$unknown !== undefined)
         return { [obj.$unknown[0]]: "UNKNOWN" };
 };
+export const MedicalScribeInputStreamFilterSensitiveLog = (obj) => {
+    if (obj.AudioEvent !== undefined)
+        return { AudioEvent: obj.AudioEvent };
+    if (obj.SessionControlEvent !== undefined)
+        return { SessionControlEvent: obj.SessionControlEvent };
+    if (obj.ConfigurationEvent !== undefined)
+        return { ConfigurationEvent: obj.ConfigurationEvent };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const MedicalScribeResultStreamFilterSensitiveLog = (obj) => {
+    if (obj.TranscriptEvent !== undefined)
+        return { TranscriptEvent: obj.TranscriptEvent };
+    if (obj.BadRequestException !== undefined)
+        return { BadRequestException: obj.BadRequestException };
+    if (obj.LimitExceededException !== undefined)
+        return { LimitExceededException: obj.LimitExceededException };
+    if (obj.InternalFailureException !== undefined)
+        return { InternalFailureException: obj.InternalFailureException };
+    if (obj.ConflictException !== undefined)
+        return { ConflictException: obj.ConflictException };
+    if (obj.ServiceUnavailableException !== undefined)
+        return { ServiceUnavailableException: obj.ServiceUnavailableException };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
 export const MedicalTranscriptResultStreamFilterSensitiveLog = (obj) => {
     if (obj.TranscriptEvent !== undefined)
         return { TranscriptEvent: obj.TranscriptEvent };
@@ -306,6 +411,14 @@ export const StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog = (
     ...obj,
     ...(obj.CallAnalyticsTranscriptResultStream && { CallAnalyticsTranscriptResultStream: "STREAMING_CONTENT" }),
 });
+export const StartMedicalScribeStreamRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.InputStream && { InputStream: "STREAMING_CONTENT" }),
+});
+export const StartMedicalScribeStreamResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ResultStream && { ResultStream: "STREAMING_CONTENT" }),
+});
 export const StartMedicalStreamTranscriptionRequestFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.AudioStream && { AudioStream: "STREAMING_CONTENT" }),

package/dist-es/protocols/Aws_restJson1.js

@@ -1,8 +1,17 @@
 import { loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody } from "@aws-sdk/core";
 import { requestBuilder as rb } from "@smithy/core";
-import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectLong as __expectLong, expectString as __expectString, isSerializableHeaderValue, limitedParseDouble as __limitedParseDouble, map, parseBoolean as __parseBoolean, strictParseInt32 as __strictParseInt32, take, withBaseException, } from "@smithy/smithy-client";
-import { AudioStream, BadRequestException, ConflictException, InternalFailureException, LimitExceededException, ServiceUnavailableException, } from "../models/models_0";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, isSerializableHeaderValue, limitedParseDouble as __limitedParseDouble, map, parseBoolean as __parseBoolean, parseEpochTimestamp as __parseEpochTimestamp, strictParseInt32 as __strictParseInt32, take, withBaseException, } from "@smithy/smithy-client";
+import { AudioStream, BadRequestException, ConflictException, InternalFailureException, LimitExceededException, MedicalScribeInputStream, ResourceNotFoundException, ServiceUnavailableException, } from "../models/models_0";
 import { TranscribeStreamingServiceException as __BaseException } from "../models/TranscribeStreamingServiceException";
+export const se_GetMedicalScribeStreamCommand = async (input, context) => {
+    const b = rb(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();
+};
 export const se_StartCallAnalyticsStreamTranscriptionCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
@@ -29,6 +38,23 @@ export const se_StartCallAnalyticsStreamTranscriptionCommand = async (input, con
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_StartMedicalScribeStreamCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xatsi]: input[_SI],
+        [_xatlc]: input[_LC],
+        [_xatsr]: [() => isSerializableHeaderValue(input[_MSRH]), () => input[_MSRH].toString()],
+        [_xatme]: input[_ME],
+    });
+    b.bp("/medical-scribe-stream");
+    let body;
+    if (input.InputStream !== undefined) {
+        body = se_MedicalScribeInputStream(input.InputStream, context);
+    }
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_StartMedicalStreamTranscriptionCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
@@ -88,6 +114,20 @@ export const se_StartStreamTranscriptionCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const de_GetMedicalScribeStreamCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        MedicalScribeStreamDetails: (_) => de_MedicalScribeStreamDetails(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_StartCallAnalyticsStreamTranscriptionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -113,6 +153,22 @@ export const de_StartCallAnalyticsStreamTranscriptionCommand = async (output, co
     contents.CallAnalyticsTranscriptResultStream = de_CallAnalyticsTranscriptResultStream(data, context);
     return contents;
 };
+export const de_StartMedicalScribeStreamCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+        [_SI]: [, output.headers[_xatsi]],
+        [_RI]: [, output.headers[_xari]],
+        [_LC]: [, output.headers[_xatlc]],
+        [_MSRH]: [() => void 0 !== output.headers[_xatsr], () => __strictParseInt32(output.headers[_xatsr])],
+        [_ME]: [, output.headers[_xatme]],
+    });
+    const data = output.body;
+    contents.ResultStream = de_MedicalScribeResultStream(data, context);
+    return contents;
+};
 export const de_StartMedicalStreamTranscriptionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -180,15 +236,18 @@ const de_CommandError = 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);
@@ -254,6 +313,19 @@ const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        Message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -275,6 +347,15 @@ const se_AudioStream = (input, context) => {
     });
     return context.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
 };
+const se_MedicalScribeInputStream = (input, context) => {
+    const eventMarshallingVisitor = (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,
+    });
+    return context.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
+};
 const se_AudioEvent_event = (input, context) => {
     const headers = {
         ":event-type": { type: "string", value: "AudioEvent" },
@@ -298,6 +379,40 @@ const se_ConfigurationEvent_event = (input, context) => {
     body = context.utf8Decoder(JSON.stringify(body));
     return { headers, body };
 };
+const se_MedicalScribeAudioEvent_event = (input, context) => {
+    const headers = {
+        ":event-type": { type: "string", value: "AudioEvent" },
+        ":message-type": { type: "string", value: "event" },
+        ":content-type": { type: "string", value: "application/octet-stream" },
+    };
+    let body = new Uint8Array();
+    if (input.AudioChunk != null) {
+        body = input.AudioChunk;
+    }
+    return { headers, body };
+};
+const se_MedicalScribeConfigurationEvent_event = (input, context) => {
+    const headers = {
+        ":event-type": { type: "string", value: "ConfigurationEvent" },
+        ":message-type": { type: "string", value: "event" },
+        ":content-type": { type: "string", value: "application/json" },
+    };
+    let body = new Uint8Array();
+    body = _json(input);
+    body = context.utf8Decoder(JSON.stringify(body));
+    return { headers, body };
+};
+const se_MedicalScribeSessionControlEvent_event = (input, context) => {
+    const headers = {
+        ":event-type": { type: "string", value: "SessionControlEvent" },
+        ":message-type": { type: "string", value: "event" },
+        ":content-type": { type: "string", value: "application/json" },
+    };
+    let body = new Uint8Array();
+    body = _json(input);
+    body = context.utf8Decoder(JSON.stringify(body));
+    return { headers, body };
+};
 const de_CallAnalyticsTranscriptResultStream = (output, context) => {
     return context.eventStreamMarshaller.deserialize(output, async (event) => {
         if (event["UtteranceEvent"] != null) {
@@ -338,6 +453,41 @@ const de_CallAnalyticsTranscriptResultStream = (output, context) => {
         return { $unknown: output };
     });
 };
+const de_MedicalScribeResultStream = (output, context) => {
+    return context.eventStreamMarshaller.deserialize(output, async (event) => {
+        if (event["TranscriptEvent"] != null) {
+            return {
+                TranscriptEvent: await de_MedicalScribeTranscriptEvent_event(event["TranscriptEvent"], context),
+            };
+        }
+        if (event["BadRequestException"] != null) {
+            return {
+                BadRequestException: await de_BadRequestException_event(event["BadRequestException"], context),
+            };
+        }
+        if (event["LimitExceededException"] != null) {
+            return {
+                LimitExceededException: await de_LimitExceededException_event(event["LimitExceededException"], context),
+            };
+        }
+        if (event["InternalFailureException"] != null) {
+            return {
+                InternalFailureException: await de_InternalFailureException_event(event["InternalFailureException"], context),
+            };
+        }
+        if (event["ConflictException"] != null) {
+            return {
+                ConflictException: await de_ConflictException_event(event["ConflictException"], context),
+            };
+        }
+        if (event["ServiceUnavailableException"] != null) {
+            return {
+                ServiceUnavailableException: await de_ServiceUnavailableException_event(event["ServiceUnavailableException"], context),
+            };
+        }
+        return { $unknown: output };
+    });
+};
 const de_MedicalTranscriptResultStream = (output, context) => {
     return context.eventStreamMarshaller.deserialize(output, async (event) => {
         if (event["TranscriptEvent"] != null) {
@@ -442,6 +592,12 @@ const de_LimitExceededException_event = async (output, context) => {
     };
     return de_LimitExceededExceptionRes(parsedOutput, context);
 };
+const de_MedicalScribeTranscriptEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, de_MedicalScribeTranscriptEvent(data, context));
+    return contents;
+};
 const de_MedicalTranscriptEvent_event = async (output, context) => {
     const contents = {};
     const data = await parseBody(output.body, context);
@@ -639,6 +795,59 @@ const de_MedicalResultList = (output, context) => {
     });
     return retVal;
 };
+const de_MedicalScribeStreamDetails = (output, context) => {
+    return take(output, {
+        ChannelDefinitions: _json,
+        EncryptionSettings: _json,
+        LanguageCode: __expectString,
+        MediaEncoding: __expectString,
+        MediaSampleRateHertz: __expectInt32,
+        PostStreamAnalyticsResult: _json,
+        PostStreamAnalyticsSettings: _json,
+        ResourceAccessRoleArn: __expectString,
+        SessionId: __expectString,
+        StreamCreatedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        StreamEndedAt: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        StreamStatus: __expectString,
+        VocabularyFilterMethod: __expectString,
+        VocabularyFilterName: __expectString,
+        VocabularyName: __expectString,
+    });
+};
+const de_MedicalScribeTranscriptEvent = (output, context) => {
+    return take(output, {
+        TranscriptSegment: (_) => de_MedicalScribeTranscriptSegment(_, context),
+    });
+};
+const de_MedicalScribeTranscriptItem = (output, context) => {
+    return take(output, {
+        BeginAudioTime: __limitedParseDouble,
+        Confidence: __limitedParseDouble,
+        Content: __expectString,
+        EndAudioTime: __limitedParseDouble,
+        Type: __expectString,
+        VocabularyFilterMatch: __expectBoolean,
+    });
+};
+const de_MedicalScribeTranscriptItemList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_MedicalScribeTranscriptItem(entry, context);
+    });
+    return retVal;
+};
+const de_MedicalScribeTranscriptSegment = (output, context) => {
+    return take(output, {
+        BeginAudioTime: __limitedParseDouble,
+        ChannelId: __expectString,
+        Content: __expectString,
+        EndAudioTime: __limitedParseDouble,
+        IsPartial: __expectBoolean,
+        Items: (_) => de_MedicalScribeTranscriptItemList(_, context),
+        SegmentId: __expectString,
+    });
+};
 const de_MedicalTranscript = (output, context) => {
     return take(output, {
         Results: (_) => de_MedicalResultList(_, context),

package/dist-types/TranscribeStreaming.d.ts

@@ -1,15 +1,29 @@
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/types";
+import { GetMedicalScribeStreamCommandInput, GetMedicalScribeStreamCommandOutput } from "./commands/GetMedicalScribeStreamCommand";
 import { StartCallAnalyticsStreamTranscriptionCommandInput, StartCallAnalyticsStreamTranscriptionCommandOutput } from "./commands/StartCallAnalyticsStreamTranscriptionCommand";
+import { StartMedicalScribeStreamCommandInput, StartMedicalScribeStreamCommandOutput } from "./commands/StartMedicalScribeStreamCommand";
 import { StartMedicalStreamTranscriptionCommandInput, StartMedicalStreamTranscriptionCommandOutput } from "./commands/StartMedicalStreamTranscriptionCommand";
 import { StartStreamTranscriptionCommandInput, StartStreamTranscriptionCommandOutput } from "./commands/StartStreamTranscriptionCommand";
 import { TranscribeStreamingClient } from "./TranscribeStreamingClient";
 export interface TranscribeStreaming {
+    /**
+     * @see {@link GetMedicalScribeStreamCommand}
+     */
+    getMedicalScribeStream(args: GetMedicalScribeStreamCommandInput, options?: __HttpHandlerOptions): Promise<GetMedicalScribeStreamCommandOutput>;
+    getMedicalScribeStream(args: GetMedicalScribeStreamCommandInput, cb: (err: any, data?: GetMedicalScribeStreamCommandOutput) => void): void;
+    getMedicalScribeStream(args: GetMedicalScribeStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetMedicalScribeStreamCommandOutput) => void): void;
     /**
      * @see {@link StartCallAnalyticsStreamTranscriptionCommand}
      */
     startCallAnalyticsStreamTranscription(args: StartCallAnalyticsStreamTranscriptionCommandInput, options?: __HttpHandlerOptions): Promise<StartCallAnalyticsStreamTranscriptionCommandOutput>;
     startCallAnalyticsStreamTranscription(args: StartCallAnalyticsStreamTranscriptionCommandInput, cb: (err: any, data?: StartCallAnalyticsStreamTranscriptionCommandOutput) => void): void;
     startCallAnalyticsStreamTranscription(args: StartCallAnalyticsStreamTranscriptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartCallAnalyticsStreamTranscriptionCommandOutput) => void): void;
+    /**
+     * @see {@link StartMedicalScribeStreamCommand}
+     */
+    startMedicalScribeStream(args: StartMedicalScribeStreamCommandInput, options?: __HttpHandlerOptions): Promise<StartMedicalScribeStreamCommandOutput>;
+    startMedicalScribeStream(args: StartMedicalScribeStreamCommandInput, cb: (err: any, data?: StartMedicalScribeStreamCommandOutput) => void): void;
+    startMedicalScribeStream(args: StartMedicalScribeStreamCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartMedicalScribeStreamCommandOutput) => void): void;
     /**
      * @see {@link StartMedicalStreamTranscriptionCommand}
      */
@@ -24,9 +38,10 @@ export interface TranscribeStreaming {
     startStreamTranscription(args: StartStreamTranscriptionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartStreamTranscriptionCommandOutput) => void): void;
 }
 /**
- * <p>Amazon Transcribe streaming offers three main types of real-time transcription:
- *       <b>Standard</b>, <b>Medical</b>, and
- *       <b>Call Analytics</b>.</p>
+ * <p>Amazon Transcribe streaming offers four main types of real-time transcription:
+ *       <b>Standard</b>, <b>Medical</b>,
+ *       <b>Call Analytics</b>,
+ *       and <b>Health Scribe</b>.</p>
  *          <ul>
  *             <li>
  *                <p>
@@ -46,6 +61,12 @@ export interface TranscribeStreaming {
  *           center audio on two different channels; if you're looking for insight into customer service calls, use this
  *           option. Refer to  for details.</p>
  *             </li>
+ *             <li>
+ *                <p>
+ *                   <b>HealthScribe transcriptions</b> are designed to
+ *           automatically create clinical notes from patient-clinician conversations using generative AI.
+ *           Refer to [here] for details.</p>
+ *             </li>
  *          </ul>
  * @public
  */

package/dist-types/TranscribeStreamingClient.d.ts

@@ -11,7 +11,9 @@ import { HttpHandlerUserInput as __HttpHandlerUserInput } from "@smithy/protocol
 import { Client as __Client, DefaultsMode as __DefaultsMode, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@smithy/smithy-client";
 import { AwsCredentialIdentityProvider, BodyLengthCalculator as __BodyLengthCalculator, CheckOptionalClientConfig as __CheckOptionalClientConfig, ChecksumConstructor as __ChecksumConstructor, Decoder as __Decoder, Encoder as __Encoder, EventStreamSerdeProvider as __EventStreamSerdeProvider, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, Provider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } from "@smithy/types";
 import { HttpAuthSchemeInputConfig, HttpAuthSchemeResolvedConfig } from "./auth/httpAuthSchemeProvider";
+import { GetMedicalScribeStreamCommandInput, GetMedicalScribeStreamCommandOutput } from "./commands/GetMedicalScribeStreamCommand";
 import { StartCallAnalyticsStreamTranscriptionCommandInput, StartCallAnalyticsStreamTranscriptionCommandOutput } from "./commands/StartCallAnalyticsStreamTranscriptionCommand";
+import { StartMedicalScribeStreamCommandInput, StartMedicalScribeStreamCommandOutput } from "./commands/StartMedicalScribeStreamCommand";
 import { StartMedicalStreamTranscriptionCommandInput, StartMedicalStreamTranscriptionCommandOutput } from "./commands/StartMedicalStreamTranscriptionCommand";
 import { StartStreamTranscriptionCommandInput, StartStreamTranscriptionCommandOutput } from "./commands/StartStreamTranscriptionCommand";
 import { ClientInputEndpointParameters, ClientResolvedEndpointParameters, EndpointParameters } from "./endpoint/EndpointParameters";
@@ -20,11 +22,11 @@ export { __Client };
 /**
  * @public
  */
-export type ServiceInputTypes = StartCallAnalyticsStreamTranscriptionCommandInput | StartMedicalStreamTranscriptionCommandInput | StartStreamTranscriptionCommandInput;
+export type ServiceInputTypes = GetMedicalScribeStreamCommandInput | StartCallAnalyticsStreamTranscriptionCommandInput | StartMedicalScribeStreamCommandInput | StartMedicalStreamTranscriptionCommandInput | StartStreamTranscriptionCommandInput;
 /**
  * @public
  */
-export type ServiceOutputTypes = StartCallAnalyticsStreamTranscriptionCommandOutput | StartMedicalStreamTranscriptionCommandOutput | StartStreamTranscriptionCommandOutput;
+export type ServiceOutputTypes = GetMedicalScribeStreamCommandOutput | StartCallAnalyticsStreamTranscriptionCommandOutput | StartMedicalScribeStreamCommandOutput | StartMedicalStreamTranscriptionCommandOutput | StartStreamTranscriptionCommandOutput;
 /**
  * @public
  */
@@ -185,9 +187,10 @@ export type TranscribeStreamingClientResolvedConfigType = __SmithyResolvedConfig
 export interface TranscribeStreamingClientResolvedConfig extends TranscribeStreamingClientResolvedConfigType {
 }
 /**
- * <p>Amazon Transcribe streaming offers three main types of real-time transcription:
- *       <b>Standard</b>, <b>Medical</b>, and
- *       <b>Call Analytics</b>.</p>
+ * <p>Amazon Transcribe streaming offers four main types of real-time transcription:
+ *       <b>Standard</b>, <b>Medical</b>,
+ *       <b>Call Analytics</b>,
+ *       and <b>Health Scribe</b>.</p>
  *          <ul>
  *             <li>
  *                <p>
@@ -207,6 +210,12 @@ export interface TranscribeStreamingClientResolvedConfig extends TranscribeStrea
  *           center audio on two different channels; if you're looking for insight into customer service calls, use this
  *           option. Refer to  for details.</p>
  *             </li>
+ *             <li>
+ *                <p>
+ *                   <b>HealthScribe transcriptions</b> are designed to
+ *           automatically create clinical notes from patient-clinician conversations using generative AI.
+ *           Refer to [here] for details.</p>
+ *             </li>
  *          </ul>
  * @public
  */