@aws-sdk/client-transcribe-streaming 3.215.0 → 3.218.0

package/dist-cjs/protocols/Aws_restJson1.js

@@ -1,10 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializeAws_restJson1StartStreamTranscriptionCommand = exports.deserializeAws_restJson1StartMedicalStreamTranscriptionCommand = exports.serializeAws_restJson1StartStreamTranscriptionCommand = exports.serializeAws_restJson1StartMedicalStreamTranscriptionCommand = void 0;
+exports.deserializeAws_restJson1StartStreamTranscriptionCommand = exports.deserializeAws_restJson1StartMedicalStreamTranscriptionCommand = exports.deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand = exports.serializeAws_restJson1StartStreamTranscriptionCommand = exports.serializeAws_restJson1StartMedicalStreamTranscriptionCommand = exports.serializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand = void 0;
 const protocol_http_1 = require("@aws-sdk/protocol-http");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const TranscribeStreamingServiceException_1 = require("../models/TranscribeStreamingServiceException");
+const serializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = map({}, isSerializableHeaderValue, {
+        "x-amzn-transcribe-language-code": input.LanguageCode,
+        "x-amzn-transcribe-sample-rate": [
+            () => isSerializableHeaderValue(input.MediaSampleRateHertz),
+            () => input.MediaSampleRateHertz.toString(),
+        ],
+        "x-amzn-transcribe-media-encoding": input.MediaEncoding,
+        "x-amzn-transcribe-vocabulary-name": input.VocabularyName,
+        "x-amzn-transcribe-session-id": input.SessionId,
+        "x-amzn-transcribe-vocabulary-filter-name": input.VocabularyFilterName,
+        "x-amzn-transcribe-vocabulary-filter-method": input.VocabularyFilterMethod,
+        "x-amzn-transcribe-language-model-name": input.LanguageModelName,
+        "x-amzn-transcribe-enable-partial-results-stabilization": [
+            () => isSerializableHeaderValue(input.EnablePartialResultsStabilization),
+            () => input.EnablePartialResultsStabilization.toString(),
+        ],
+        "x-amzn-transcribe-partial-results-stability": input.PartialResultsStability,
+        "x-amzn-transcribe-content-identification-type": input.ContentIdentificationType,
+        "x-amzn-transcribe-content-redaction-type": input.ContentRedactionType,
+        "x-amzn-transcribe-pii-entity-types": input.PiiEntityTypes,
+    });
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/call-analytics-stream-transcription";
+    let body;
+    if (input.AudioStream !== undefined) {
+        body = serializeAws_restJson1AudioStream(input.AudioStream, context);
+    }
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand = serializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand;
 const serializeAws_restJson1StartMedicalStreamTranscriptionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
@@ -107,6 +146,70 @@ const serializeAws_restJson1StartStreamTranscriptionCommand = async (input, cont
     });
 };
 exports.serializeAws_restJson1StartStreamTranscriptionCommand = serializeAws_restJson1StartStreamTranscriptionCommand;
+const deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+        RequestId: [, output.headers["x-amzn-request-id"]],
+        LanguageCode: [, output.headers["x-amzn-transcribe-language-code"]],
+        MediaSampleRateHertz: [
+            () => void 0 !== output.headers["x-amzn-transcribe-sample-rate"],
+            () => (0, smithy_client_1.strictParseInt32)(output.headers["x-amzn-transcribe-sample-rate"]),
+        ],
+        MediaEncoding: [, output.headers["x-amzn-transcribe-media-encoding"]],
+        VocabularyName: [, output.headers["x-amzn-transcribe-vocabulary-name"]],
+        SessionId: [, output.headers["x-amzn-transcribe-session-id"]],
+        VocabularyFilterName: [, output.headers["x-amzn-transcribe-vocabulary-filter-name"]],
+        VocabularyFilterMethod: [, output.headers["x-amzn-transcribe-vocabulary-filter-method"]],
+        LanguageModelName: [, output.headers["x-amzn-transcribe-language-model-name"]],
+        EnablePartialResultsStabilization: [
+            () => void 0 !== output.headers["x-amzn-transcribe-enable-partial-results-stabilization"],
+            () => (0, smithy_client_1.parseBoolean)(output.headers["x-amzn-transcribe-enable-partial-results-stabilization"]),
+        ],
+        PartialResultsStability: [, output.headers["x-amzn-transcribe-partial-results-stability"]],
+        ContentIdentificationType: [, output.headers["x-amzn-transcribe-content-identification-type"]],
+        ContentRedactionType: [, output.headers["x-amzn-transcribe-content-redaction-type"]],
+        PiiEntityTypes: [, output.headers["x-amzn-transcribe-pii-entity-types"]],
+    });
+    const data = output.body;
+    contents.CallAnalyticsTranscriptResultStream = deserializeAws_restJson1CallAnalyticsTranscriptResultStream(data, context);
+    return contents;
+};
+exports.deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand = deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand;
+const deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommandError = 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 deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.transcribestreaming#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalFailureException":
+        case "com.amazonaws.transcribestreaming#InternalFailureException":
+            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.transcribestreaming#LimitExceededException":
+            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.transcribestreaming#ServiceUnavailableException":
+            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: TranscribeStreamingServiceException_1.TranscribeStreamingServiceException,
+                errorCode,
+            });
+    }
+};
 const deserializeAws_restJson1StartMedicalStreamTranscriptionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1StartMedicalStreamTranscriptionCommandError(output, context);
@@ -323,6 +426,7 @@ const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parse
 const serializeAws_restJson1AudioStream = (input, context) => {
     const eventMarshallingVisitor = (event) => models_0_1.AudioStream.visit(event, {
         AudioEvent: (value) => serializeAws_restJson1AudioEvent_event(value, context),
+        ConfigurationEvent: (value) => serializeAws_restJson1ConfigurationEvent_event(value, context),
         _: (value) => value,
     });
     return context.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
@@ -339,6 +443,57 @@ const serializeAws_restJson1AudioEvent_event = (input, context) => {
     }
     return { headers, body };
 };
+const serializeAws_restJson1ConfigurationEvent_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 = serializeAws_restJson1ConfigurationEvent(input, context);
+    body = context.utf8Decoder(JSON.stringify(body));
+    return { headers, body };
+};
+const deserializeAws_restJson1CallAnalyticsTranscriptResultStream = (output, context) => {
+    return context.eventStreamMarshaller.deserialize(output, async (event) => {
+        if (event["UtteranceEvent"] != null) {
+            return {
+                UtteranceEvent: await deserializeAws_restJson1UtteranceEvent_event(event["UtteranceEvent"], context),
+            };
+        }
+        if (event["CategoryEvent"] != null) {
+            return {
+                CategoryEvent: await deserializeAws_restJson1CategoryEvent_event(event["CategoryEvent"], context),
+            };
+        }
+        if (event["BadRequestException"] != null) {
+            return {
+                BadRequestException: await deserializeAws_restJson1BadRequestException_event(event["BadRequestException"], context),
+            };
+        }
+        if (event["LimitExceededException"] != null) {
+            return {
+                LimitExceededException: await deserializeAws_restJson1LimitExceededException_event(event["LimitExceededException"], context),
+            };
+        }
+        if (event["InternalFailureException"] != null) {
+            return {
+                InternalFailureException: await deserializeAws_restJson1InternalFailureException_event(event["InternalFailureException"], context),
+            };
+        }
+        if (event["ConflictException"] != null) {
+            return {
+                ConflictException: await deserializeAws_restJson1ConflictException_event(event["ConflictException"], context),
+            };
+        }
+        if (event["ServiceUnavailableException"] != null) {
+            return {
+                ServiceUnavailableException: await deserializeAws_restJson1ServiceUnavailableException_event(event["ServiceUnavailableException"], context),
+            };
+        }
+        return { $unknown: output };
+    });
+};
 const deserializeAws_restJson1MedicalTranscriptResultStream = (output, context) => {
     return context.eventStreamMarshaller.deserialize(output, async (event) => {
         if (event["TranscriptEvent"] != null) {
@@ -416,6 +571,12 @@ const deserializeAws_restJson1BadRequestException_event = async (output, context
     };
     return deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
 };
+const deserializeAws_restJson1CategoryEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, deserializeAws_restJson1CategoryEvent(data, context));
+    return contents;
+};
 const deserializeAws_restJson1ConflictException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
@@ -456,6 +617,43 @@ const deserializeAws_restJson1TranscriptEvent_event = async (output, context) =>
     Object.assign(contents, deserializeAws_restJson1TranscriptEvent(data, context));
     return contents;
 };
+const deserializeAws_restJson1UtteranceEvent_event = async (output, context) => {
+    const contents = {};
+    const data = await parseBody(output.body, context);
+    Object.assign(contents, deserializeAws_restJson1UtteranceEvent(data, context));
+    return contents;
+};
+const serializeAws_restJson1ChannelDefinition = (input, context) => {
+    return {
+        ...(input.ChannelId != null && { ChannelId: input.ChannelId }),
+        ...(input.ParticipantRole != null && { ParticipantRole: input.ParticipantRole }),
+    };
+};
+const serializeAws_restJson1ChannelDefinitions = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1ChannelDefinition(entry, context);
+    });
+};
+const serializeAws_restJson1ConfigurationEvent = (input, context) => {
+    return {
+        ...(input.ChannelDefinitions != null && {
+            ChannelDefinitions: serializeAws_restJson1ChannelDefinitions(input.ChannelDefinitions, context),
+        }),
+        ...(input.PostCallAnalyticsSettings != null && {
+            PostCallAnalyticsSettings: serializeAws_restJson1PostCallAnalyticsSettings(input.PostCallAnalyticsSettings, context),
+        }),
+    };
+};
+const serializeAws_restJson1PostCallAnalyticsSettings = (input, context) => {
+    return {
+        ...(input.ContentRedactionOutput != null && { ContentRedactionOutput: input.ContentRedactionOutput }),
+        ...(input.DataAccessRoleArn != null && { DataAccessRoleArn: input.DataAccessRoleArn }),
+        ...(input.OutputEncryptionKMSKeyId != null && { OutputEncryptionKMSKeyId: input.OutputEncryptionKMSKeyId }),
+        ...(input.OutputLocation != null && { OutputLocation: input.OutputLocation }),
+    };
+};
 const deserializeAws_restJson1Alternative = (output, context) => {
     return {
         Entities: output.Entities != null ? deserializeAws_restJson1EntityList(output.Entities, context) : undefined,
@@ -474,6 +672,65 @@ const deserializeAws_restJson1AlternativeList = (output, context) => {
     });
     return retVal;
 };
+const deserializeAws_restJson1CallAnalyticsEntity = (output, context) => {
+    return {
+        BeginOffsetMillis: (0, smithy_client_1.expectLong)(output.BeginOffsetMillis),
+        Category: (0, smithy_client_1.expectString)(output.Category),
+        Confidence: (0, smithy_client_1.limitedParseDouble)(output.Confidence),
+        Content: (0, smithy_client_1.expectString)(output.Content),
+        EndOffsetMillis: (0, smithy_client_1.expectLong)(output.EndOffsetMillis),
+        Type: (0, smithy_client_1.expectString)(output.Type),
+    };
+};
+const deserializeAws_restJson1CallAnalyticsEntityList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1CallAnalyticsEntity(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1CallAnalyticsItem = (output, context) => {
+    return {
+        BeginOffsetMillis: (0, smithy_client_1.expectLong)(output.BeginOffsetMillis),
+        Confidence: (0, smithy_client_1.limitedParseDouble)(output.Confidence),
+        Content: (0, smithy_client_1.expectString)(output.Content),
+        EndOffsetMillis: (0, smithy_client_1.expectLong)(output.EndOffsetMillis),
+        Stable: (0, smithy_client_1.expectBoolean)(output.Stable),
+        Type: (0, smithy_client_1.expectString)(output.Type),
+        VocabularyFilterMatch: (0, smithy_client_1.expectBoolean)(output.VocabularyFilterMatch),
+    };
+};
+const deserializeAws_restJson1CallAnalyticsItemList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1CallAnalyticsItem(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1CategoryEvent = (output, context) => {
+    return {
+        MatchedCategories: output.MatchedCategories != null
+            ? deserializeAws_restJson1StringList(output.MatchedCategories, context)
+            : undefined,
+        MatchedDetails: output.MatchedDetails != null
+            ? deserializeAws_restJson1MatchedCategoryDetails(output.MatchedDetails, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1CharacterOffsets = (output, context) => {
+    return {
+        Begin: (0, smithy_client_1.expectInt32)(output.Begin),
+        End: (0, smithy_client_1.expectInt32)(output.End),
+    };
+};
 const deserializeAws_restJson1Entity = (output, context) => {
     return {
         Category: (0, smithy_client_1.expectString)(output.Category),
@@ -495,6 +752,24 @@ const deserializeAws_restJson1EntityList = (output, context) => {
     });
     return retVal;
 };
+const deserializeAws_restJson1IssueDetected = (output, context) => {
+    return {
+        CharacterOffsets: output.CharacterOffsets != null
+            ? deserializeAws_restJson1CharacterOffsets(output.CharacterOffsets, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1IssuesDetected = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1IssueDetected(entry, context);
+    });
+    return retVal;
+};
 const deserializeAws_restJson1Item = (output, context) => {
     return {
         Confidence: (0, smithy_client_1.limitedParseDouble)(output.Confidence),
@@ -535,6 +810,15 @@ const deserializeAws_restJson1LanguageWithScore = (output, context) => {
         Score: (0, smithy_client_1.limitedParseDouble)(output.Score),
     };
 };
+const deserializeAws_restJson1MatchedCategoryDetails = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = deserializeAws_restJson1PointsOfInterest(value, context);
+        return acc;
+    }, {});
+};
 const deserializeAws_restJson1MedicalAlternative = (output, context) => {
     return {
         Entities: output.Entities != null ? deserializeAws_restJson1MedicalEntityList(output.Entities, context) : undefined,
@@ -627,6 +911,13 @@ const deserializeAws_restJson1MedicalTranscriptEvent = (output, context) => {
         Transcript: output.Transcript != null ? deserializeAws_restJson1MedicalTranscript(output.Transcript, context) : undefined,
     };
 };
+const deserializeAws_restJson1PointsOfInterest = (output, context) => {
+    return {
+        TimestampRanges: output.TimestampRanges != null
+            ? deserializeAws_restJson1TimestampRanges(output.TimestampRanges, context)
+            : undefined,
+    };
+};
 const deserializeAws_restJson1Result = (output, context) => {
     return {
         Alternatives: output.Alternatives != null ? deserializeAws_restJson1AlternativeList(output.Alternatives, context) : undefined,
@@ -652,6 +943,34 @@ const deserializeAws_restJson1ResultList = (output, context) => {
     });
     return retVal;
 };
+const deserializeAws_restJson1StringList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return (0, smithy_client_1.expectString)(entry);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1TimestampRange = (output, context) => {
+    return {
+        BeginOffsetMillis: (0, smithy_client_1.expectLong)(output.BeginOffsetMillis),
+        EndOffsetMillis: (0, smithy_client_1.expectLong)(output.EndOffsetMillis),
+    };
+};
+const deserializeAws_restJson1TimestampRanges = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1TimestampRange(entry, context);
+    });
+    return retVal;
+};
 const deserializeAws_restJson1Transcript = (output, context) => {
     return {
         Results: output.Results != null ? deserializeAws_restJson1ResultList(output.Results, context) : undefined,
@@ -662,6 +981,22 @@ const deserializeAws_restJson1TranscriptEvent = (output, context) => {
         Transcript: output.Transcript != null ? deserializeAws_restJson1Transcript(output.Transcript, context) : undefined,
     };
 };
+const deserializeAws_restJson1UtteranceEvent = (output, context) => {
+    return {
+        BeginOffsetMillis: (0, smithy_client_1.expectLong)(output.BeginOffsetMillis),
+        EndOffsetMillis: (0, smithy_client_1.expectLong)(output.EndOffsetMillis),
+        Entities: output.Entities != null ? deserializeAws_restJson1CallAnalyticsEntityList(output.Entities, context) : undefined,
+        IsPartial: (0, smithy_client_1.expectBoolean)(output.IsPartial),
+        IssuesDetected: output.IssuesDetected != null
+            ? deserializeAws_restJson1IssuesDetected(output.IssuesDetected, context)
+            : undefined,
+        Items: output.Items != null ? deserializeAws_restJson1CallAnalyticsItemList(output.Items, context) : undefined,
+        ParticipantRole: (0, smithy_client_1.expectString)(output.ParticipantRole),
+        Sentiment: (0, smithy_client_1.expectString)(output.Sentiment),
+        Transcript: (0, smithy_client_1.expectString)(output.Transcript),
+        UtteranceId: (0, smithy_client_1.expectString)(output.UtteranceId),
+    };
+};
 const deserializeMetadata = (output) => ({
     httpStatusCode: output.statusCode,
     requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],

package/dist-es/TranscribeStreaming.js

@@ -1,7 +1,22 @@
+import { StartCallAnalyticsStreamTranscriptionCommand, } from "./commands/StartCallAnalyticsStreamTranscriptionCommand";
 import { StartMedicalStreamTranscriptionCommand, } from "./commands/StartMedicalStreamTranscriptionCommand";
 import { StartStreamTranscriptionCommand, } from "./commands/StartStreamTranscriptionCommand";
 import { TranscribeStreamingClient } from "./TranscribeStreamingClient";
 export class TranscribeStreaming extends TranscribeStreamingClient {
+    startCallAnalyticsStreamTranscription(args, optionsOrCb, cb) {
+        const command = new StartCallAnalyticsStreamTranscriptionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     startMedicalStreamTranscription(args, optionsOrCb, cb) {
         const command = new StartMedicalStreamTranscriptionCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/StartCallAnalyticsStreamTranscriptionCommand.js

@@ -0,0 +1,44 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getEventStreamPlugin } from "@aws-sdk/middleware-eventstream";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog, StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand, serializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand, } from "../protocols/Aws_restJson1";
+export class StartCallAnalyticsStreamTranscriptionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, StartCallAnalyticsStreamTranscriptionCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEventStreamPlugin(configuration));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "TranscribeStreamingClient";
+        const commandName = "StartCallAnalyticsStreamTranscriptionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

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

package/dist-es/endpoint/ruleset.js

@@ -274,12 +274,12 @@ export const ruleSet = {
                                                         {
                                                             ref: "Region",
                                                         },
-                                                        "transcribestreaming-us-west-2",
+                                                        "transcribestreaming-us-east-2",
                                                     ],
                                                 },
                                             ],
                                             endpoint: {
-                                                url: "https://transcribestreaming-fips.us-west-2.amazonaws.com",
+                                                url: "https://transcribestreaming-fips.us-east-2.amazonaws.com",
                                                 properties: {},
                                                 headers: {},
                                             },
@@ -293,12 +293,12 @@ export const ruleSet = {
                                                         {
                                                             ref: "Region",
                                                         },
-                                                        "transcribestreaming-us-east-2",
+                                                        "transcribestreaming-us-west-2",
                                                     ],
                                                 },
                                             ],
                                             endpoint: {
-                                                url: "https://transcribestreaming-fips.us-east-2.amazonaws.com",
+                                                url: "https://transcribestreaming-fips.us-west-2.amazonaws.com",
                                                 properties: {},
                                                 headers: {},
                                             },