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

package/dist-es/models/models_0.js

@@ -4,11 +4,23 @@ export var ItemType;
     ItemType["PRONUNCIATION"] = "pronunciation";
     ItemType["PUNCTUATION"] = "punctuation";
 })(ItemType || (ItemType = {}));
+export var ParticipantRole;
+(function (ParticipantRole) {
+    ParticipantRole["AGENT"] = "AGENT";
+    ParticipantRole["CUSTOMER"] = "CUSTOMER";
+})(ParticipantRole || (ParticipantRole = {}));
+export var ContentRedactionOutput;
+(function (ContentRedactionOutput) {
+    ContentRedactionOutput["REDACTED"] = "redacted";
+    ContentRedactionOutput["REDACTED_AND_UNREDACTED"] = "redacted_and_unredacted";
+})(ContentRedactionOutput || (ContentRedactionOutput = {}));
 export var AudioStream;
 (function (AudioStream) {
     AudioStream.visit = (value, visitor) => {
         if (value.AudioEvent !== undefined)
             return visitor.AudioEvent(value.AudioEvent);
+        if (value.ConfigurationEvent !== undefined)
+            return visitor.ConfigurationEvent(value.ConfigurationEvent);
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(AudioStream || (AudioStream = {}));
@@ -25,6 +37,18 @@ export class BadRequestException extends __BaseException {
         this.Message = opts.Message;
     }
 }
+export var CallAnalyticsLanguageCode;
+(function (CallAnalyticsLanguageCode) {
+    CallAnalyticsLanguageCode["DE_DE"] = "de-DE";
+    CallAnalyticsLanguageCode["EN_AU"] = "en-AU";
+    CallAnalyticsLanguageCode["EN_GB"] = "en-GB";
+    CallAnalyticsLanguageCode["EN_US"] = "en-US";
+    CallAnalyticsLanguageCode["ES_US"] = "es-US";
+    CallAnalyticsLanguageCode["FR_CA"] = "fr-CA";
+    CallAnalyticsLanguageCode["FR_FR"] = "fr-FR";
+    CallAnalyticsLanguageCode["IT_IT"] = "it-IT";
+    CallAnalyticsLanguageCode["PT_BR"] = "pt-BR";
+})(CallAnalyticsLanguageCode || (CallAnalyticsLanguageCode = {}));
 export class ConflictException extends __BaseException {
     constructor(opts) {
         super({
@@ -38,14 +62,6 @@ export class ConflictException extends __BaseException {
         this.Message = opts.Message;
     }
 }
-export var ContentIdentificationType;
-(function (ContentIdentificationType) {
-    ContentIdentificationType["PII"] = "PII";
-})(ContentIdentificationType || (ContentIdentificationType = {}));
-export var ContentRedactionType;
-(function (ContentRedactionType) {
-    ContentRedactionType["PII"] = "PII";
-})(ContentRedactionType || (ContentRedactionType = {}));
 export class InternalFailureException extends __BaseException {
     constructor(opts) {
         super({
@@ -59,6 +75,67 @@ export class InternalFailureException extends __BaseException {
         this.Message = opts.Message;
     }
 }
+export class LimitExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "LimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "LimitExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, LimitExceededException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export class ServiceUnavailableException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ServiceUnavailableException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "ServiceUnavailableException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, ServiceUnavailableException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export var Sentiment;
+(function (Sentiment) {
+    Sentiment["MIXED"] = "MIXED";
+    Sentiment["NEGATIVE"] = "NEGATIVE";
+    Sentiment["NEUTRAL"] = "NEUTRAL";
+    Sentiment["POSITIVE"] = "POSITIVE";
+})(Sentiment || (Sentiment = {}));
+export var CallAnalyticsTranscriptResultStream;
+(function (CallAnalyticsTranscriptResultStream) {
+    CallAnalyticsTranscriptResultStream.visit = (value, visitor) => {
+        if (value.UtteranceEvent !== undefined)
+            return visitor.UtteranceEvent(value.UtteranceEvent);
+        if (value.CategoryEvent !== undefined)
+            return visitor.CategoryEvent(value.CategoryEvent);
+        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]);
+    };
+})(CallAnalyticsTranscriptResultStream || (CallAnalyticsTranscriptResultStream = {}));
+export var ContentIdentificationType;
+(function (ContentIdentificationType) {
+    ContentIdentificationType["PII"] = "PII";
+})(ContentIdentificationType || (ContentIdentificationType = {}));
+export var ContentRedactionType;
+(function (ContentRedactionType) {
+    ContentRedactionType["PII"] = "PII";
+})(ContentRedactionType || (ContentRedactionType = {}));
 export var LanguageCode;
 (function (LanguageCode) {
     LanguageCode["DE_DE"] = "de-DE";
@@ -76,19 +153,6 @@ export var LanguageCode;
     LanguageCode["TH_TH"] = "th-TH";
     LanguageCode["ZH_CN"] = "zh-CN";
 })(LanguageCode || (LanguageCode = {}));
-export class LimitExceededException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "LimitExceededException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "LimitExceededException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, LimitExceededException.prototype);
-        this.Message = opts.Message;
-    }
-}
 export var MediaEncoding;
 (function (MediaEncoding) {
     MediaEncoding["FLAC"] = "flac";
@@ -99,19 +163,6 @@ export var MedicalContentIdentificationType;
 (function (MedicalContentIdentificationType) {
     MedicalContentIdentificationType["PHI"] = "PHI";
 })(MedicalContentIdentificationType || (MedicalContentIdentificationType = {}));
-export class ServiceUnavailableException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "ServiceUnavailableException",
-            $fault: "server",
-            ...opts,
-        });
-        this.name = "ServiceUnavailableException";
-        this.$fault = "server";
-        Object.setPrototypeOf(this, ServiceUnavailableException.prototype);
-        this.Message = opts.Message;
-    }
-}
 export var MedicalTranscriptResultStream;
 (function (MedicalTranscriptResultStream) {
     MedicalTranscriptResultStream.visit = (value, visitor) => {
@@ -145,17 +196,17 @@ export var Specialty;
     Specialty["RADIOLOGY"] = "RADIOLOGY";
     Specialty["UROLOGY"] = "UROLOGY";
 })(Specialty || (Specialty = {}));
-export var Type;
-(function (Type) {
-    Type["CONVERSATION"] = "CONVERSATION";
-    Type["DICTATION"] = "DICTATION";
-})(Type || (Type = {}));
 export var VocabularyFilterMethod;
 (function (VocabularyFilterMethod) {
     VocabularyFilterMethod["MASK"] = "mask";
     VocabularyFilterMethod["REMOVE"] = "remove";
     VocabularyFilterMethod["TAG"] = "tag";
 })(VocabularyFilterMethod || (VocabularyFilterMethod = {}));
+export var Type;
+(function (Type) {
+    Type["CONVERSATION"] = "CONVERSATION";
+    Type["DICTATION"] = "DICTATION";
+})(Type || (Type = {}));
 export var TranscriptResultStream;
 (function (TranscriptResultStream) {
     TranscriptResultStream.visit = (value, visitor) => {
@@ -186,9 +237,62 @@ export const AlternativeFilterSensitiveLog = (obj) => ({
 export const AudioEventFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const ChannelDefinitionFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PostCallAnalyticsSettingsFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ConfigurationEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const AudioStreamFilterSensitiveLog = (obj) => {
     if (obj.AudioEvent !== undefined)
         return { AudioEvent: AudioEventFilterSensitiveLog(obj.AudioEvent) };
+    if (obj.ConfigurationEvent !== undefined)
+        return { ConfigurationEvent: ConfigurationEventFilterSensitiveLog(obj.ConfigurationEvent) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CallAnalyticsEntityFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CallAnalyticsItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const TimestampRangeFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PointsOfInterestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CategoryEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CharacterOffsetsFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const IssueDetectedFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UtteranceEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CallAnalyticsTranscriptResultStreamFilterSensitiveLog = (obj) => {
+    if (obj.UtteranceEvent !== undefined)
+        return { UtteranceEvent: UtteranceEventFilterSensitiveLog(obj.UtteranceEvent) };
+    if (obj.CategoryEvent !== undefined)
+        return { CategoryEvent: CategoryEventFilterSensitiveLog(obj.CategoryEvent) };
+    if (obj.BadRequestException !== undefined)
+        return { BadRequestException: obj.BadRequestException };
+    if (obj.LimitExceededException !== undefined)
+        return { LimitExceededException: obj.LimitExceededException };
+    if (obj.InternalFailureException !== undefined)
+        return { InternalFailureException: obj.InternalFailureException };
+    if (obj.ConflictException !== undefined)
+        return { ConflictException: obj.ConflictException };
+    if (obj.ServiceUnavailableException !== undefined)
+        return { ServiceUnavailableException: obj.ServiceUnavailableException };
     if (obj.$unknown !== undefined)
         return { [obj.$unknown[0]]: "UNKNOWN" };
 };
@@ -232,6 +336,14 @@ export const MedicalTranscriptResultStreamFilterSensitiveLog = (obj) => {
 export const ResultFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const StartCallAnalyticsStreamTranscriptionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.AudioStream && { AudioStream: "STREAMING_CONTENT" }),
+});
+export const StartCallAnalyticsStreamTranscriptionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.CallAnalyticsTranscriptResultStream && { CallAnalyticsTranscriptResultStream: "STREAMING_CONTENT" }),
+});
 export const StartMedicalStreamTranscriptionRequestFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.AudioStream && { AudioStream: "STREAMING_CONTENT" }),

package/dist-es/protocols/Aws_restJson1.js

@@ -1,7 +1,45 @@
 import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
-import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map as __map, parseBoolean as __parseBoolean, strictParseInt32 as __strictParseInt32, throwDefaultError, } from "@aws-sdk/smithy-client";
+import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map as __map, parseBoolean as __parseBoolean, strictParseInt32 as __strictParseInt32, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { AudioStream, BadRequestException, ConflictException, InternalFailureException, LimitExceededException, ServiceUnavailableException, } from "../models/models_0";
 import { TranscribeStreamingServiceException as __BaseException } from "../models/TranscribeStreamingServiceException";
+export 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 __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1StartMedicalStreamTranscriptionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
@@ -102,6 +140,69 @@ export const serializeAws_restJson1StartStreamTranscriptionCommand = async (inpu
         body,
     });
 };
+export 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"],
+            () => __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"],
+            () => __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;
+};
+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;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1StartMedicalStreamTranscriptionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1StartMedicalStreamTranscriptionCommandError(output, context);
@@ -316,6 +417,7 @@ const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parse
 const serializeAws_restJson1AudioStream = (input, context) => {
     const eventMarshallingVisitor = (event) => 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);
@@ -332,6 +434,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) {
@@ -409,6 +562,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,
@@ -449,6 +608,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,
@@ -467,6 +663,65 @@ const deserializeAws_restJson1AlternativeList = (output, context) => {
     });
     return retVal;
 };
+const deserializeAws_restJson1CallAnalyticsEntity = (output, context) => {
+    return {
+        BeginOffsetMillis: __expectLong(output.BeginOffsetMillis),
+        Category: __expectString(output.Category),
+        Confidence: __limitedParseDouble(output.Confidence),
+        Content: __expectString(output.Content),
+        EndOffsetMillis: __expectLong(output.EndOffsetMillis),
+        Type: __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: __expectLong(output.BeginOffsetMillis),
+        Confidence: __limitedParseDouble(output.Confidence),
+        Content: __expectString(output.Content),
+        EndOffsetMillis: __expectLong(output.EndOffsetMillis),
+        Stable: __expectBoolean(output.Stable),
+        Type: __expectString(output.Type),
+        VocabularyFilterMatch: __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: __expectInt32(output.Begin),
+        End: __expectInt32(output.End),
+    };
+};
 const deserializeAws_restJson1Entity = (output, context) => {
     return {
         Category: __expectString(output.Category),
@@ -488,6 +743,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: __limitedParseDouble(output.Confidence),
@@ -528,6 +801,15 @@ const deserializeAws_restJson1LanguageWithScore = (output, context) => {
         Score: __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,
@@ -620,6 +902,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,
@@ -645,6 +934,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 __expectString(entry);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1TimestampRange = (output, context) => {
+    return {
+        BeginOffsetMillis: __expectLong(output.BeginOffsetMillis),
+        EndOffsetMillis: __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,
@@ -655,6 +972,22 @@ const deserializeAws_restJson1TranscriptEvent = (output, context) => {
         Transcript: output.Transcript != null ? deserializeAws_restJson1Transcript(output.Transcript, context) : undefined,
     };
 };
+const deserializeAws_restJson1UtteranceEvent = (output, context) => {
+    return {
+        BeginOffsetMillis: __expectLong(output.BeginOffsetMillis),
+        EndOffsetMillis: __expectLong(output.EndOffsetMillis),
+        Entities: output.Entities != null ? deserializeAws_restJson1CallAnalyticsEntityList(output.Entities, context) : undefined,
+        IsPartial: __expectBoolean(output.IsPartial),
+        IssuesDetected: output.IssuesDetected != null
+            ? deserializeAws_restJson1IssuesDetected(output.IssuesDetected, context)
+            : undefined,
+        Items: output.Items != null ? deserializeAws_restJson1CallAnalyticsItemList(output.Items, context) : undefined,
+        ParticipantRole: __expectString(output.ParticipantRole),
+        Sentiment: __expectString(output.Sentiment),
+        Transcript: __expectString(output.Transcript),
+        UtteranceId: __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"],