@aws-sdk/client-transcribe-streaming 3.306.0 → 3.310.0

package/dist-cjs/protocols/Aws_restJson1.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializeAws_restJson1StartStreamTranscriptionCommand = exports.deserializeAws_restJson1StartMedicalStreamTranscriptionCommand = exports.deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand = exports.serializeAws_restJson1StartStreamTranscriptionCommand = exports.serializeAws_restJson1StartMedicalStreamTranscriptionCommand = exports.serializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand = void 0;
+exports.de_StartStreamTranscriptionCommand = exports.de_StartMedicalStreamTranscriptionCommand = exports.de_StartCallAnalyticsStreamTranscriptionCommand = exports.se_StartStreamTranscriptionCommand = exports.se_StartMedicalStreamTranscriptionCommand = exports.se_StartCallAnalyticsStreamTranscriptionCommand = 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 se_StartCallAnalyticsStreamTranscriptionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
         "x-amzn-transcribe-language-code": input.LanguageCode,
@@ -31,7 +31,7 @@ const serializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand = async
     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);
+        body = se_AudioStream(input.AudioStream, context);
     }
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -43,8 +43,8 @@ const serializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand = async
         body,
     });
 };
-exports.serializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand = serializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand;
-const serializeAws_restJson1StartMedicalStreamTranscriptionCommand = async (input, context) => {
+exports.se_StartCallAnalyticsStreamTranscriptionCommand = se_StartCallAnalyticsStreamTranscriptionCommand;
+const se_StartMedicalStreamTranscriptionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
         "x-amzn-transcribe-language-code": input.LanguageCode,
@@ -74,7 +74,7 @@ const serializeAws_restJson1StartMedicalStreamTranscriptionCommand = async (inpu
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/medical-stream-transcription";
     let body;
     if (input.AudioStream !== undefined) {
-        body = serializeAws_restJson1AudioStream(input.AudioStream, context);
+        body = se_AudioStream(input.AudioStream, context);
     }
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -86,8 +86,8 @@ const serializeAws_restJson1StartMedicalStreamTranscriptionCommand = async (inpu
         body,
     });
 };
-exports.serializeAws_restJson1StartMedicalStreamTranscriptionCommand = serializeAws_restJson1StartMedicalStreamTranscriptionCommand;
-const serializeAws_restJson1StartStreamTranscriptionCommand = async (input, context) => {
+exports.se_StartMedicalStreamTranscriptionCommand = se_StartMedicalStreamTranscriptionCommand;
+const se_StartStreamTranscriptionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
         "x-amzn-transcribe-language-code": input.LanguageCode,
@@ -133,7 +133,7 @@ const serializeAws_restJson1StartStreamTranscriptionCommand = async (input, cont
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/stream-transcription";
     let body;
     if (input.AudioStream !== undefined) {
-        body = serializeAws_restJson1AudioStream(input.AudioStream, context);
+        body = se_AudioStream(input.AudioStream, context);
     }
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -145,10 +145,10 @@ const serializeAws_restJson1StartStreamTranscriptionCommand = async (input, cont
         body,
     });
 };
-exports.serializeAws_restJson1StartStreamTranscriptionCommand = serializeAws_restJson1StartStreamTranscriptionCommand;
-const deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand = async (output, context) => {
+exports.se_StartStreamTranscriptionCommand = se_StartStreamTranscriptionCommand;
+const de_StartCallAnalyticsStreamTranscriptionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommandError(output, context);
+        return de_StartCallAnalyticsStreamTranscriptionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -174,11 +174,11 @@ const deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand = asy
         PiiEntityTypes: [, output.headers["x-amzn-transcribe-pii-entity-types"]],
     });
     const data = output.body;
-    contents.CallAnalyticsTranscriptResultStream = deserializeAws_restJson1CallAnalyticsTranscriptResultStream(data, context);
+    contents.CallAnalyticsTranscriptResultStream = de_CallAnalyticsTranscriptResultStream(data, context);
     return contents;
 };
-exports.deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand = deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand;
-const deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommandError = async (output, context) => {
+exports.de_StartCallAnalyticsStreamTranscriptionCommand = de_StartCallAnalyticsStreamTranscriptionCommand;
+const de_StartCallAnalyticsStreamTranscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -187,19 +187,19 @@ const deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommandError
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribestreaming#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribestreaming#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribestreaming#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribestreaming#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.transcribestreaming#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -210,9 +210,9 @@ const deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommandError
             });
     }
 };
-const deserializeAws_restJson1StartMedicalStreamTranscriptionCommand = async (output, context) => {
+const de_StartMedicalStreamTranscriptionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1StartMedicalStreamTranscriptionCommandError(output, context);
+        return de_StartMedicalStreamTranscriptionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -242,11 +242,11 @@ const deserializeAws_restJson1StartMedicalStreamTranscriptionCommand = async (ou
         ContentIdentificationType: [, output.headers["x-amzn-transcribe-content-identification-type"]],
     });
     const data = output.body;
-    contents.TranscriptResultStream = deserializeAws_restJson1MedicalTranscriptResultStream(data, context);
+    contents.TranscriptResultStream = de_MedicalTranscriptResultStream(data, context);
     return contents;
 };
-exports.deserializeAws_restJson1StartMedicalStreamTranscriptionCommand = deserializeAws_restJson1StartMedicalStreamTranscriptionCommand;
-const deserializeAws_restJson1StartMedicalStreamTranscriptionCommandError = async (output, context) => {
+exports.de_StartMedicalStreamTranscriptionCommand = de_StartMedicalStreamTranscriptionCommand;
+const de_StartMedicalStreamTranscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -255,19 +255,19 @@ const deserializeAws_restJson1StartMedicalStreamTranscriptionCommandError = asyn
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribestreaming#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribestreaming#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribestreaming#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribestreaming#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.transcribestreaming#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -278,9 +278,9 @@ const deserializeAws_restJson1StartMedicalStreamTranscriptionCommandError = asyn
             });
     }
 };
-const deserializeAws_restJson1StartStreamTranscriptionCommand = async (output, context) => {
+const de_StartStreamTranscriptionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1StartStreamTranscriptionCommandError(output, context);
+        return de_StartStreamTranscriptionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -326,11 +326,11 @@ const deserializeAws_restJson1StartStreamTranscriptionCommand = async (output, c
         VocabularyFilterNames: [, output.headers["x-amzn-transcribe-vocabulary-filter-names"]],
     });
     const data = output.body;
-    contents.TranscriptResultStream = deserializeAws_restJson1TranscriptResultStream(data, context);
+    contents.TranscriptResultStream = de_TranscriptResultStream(data, context);
     return contents;
 };
-exports.deserializeAws_restJson1StartStreamTranscriptionCommand = deserializeAws_restJson1StartStreamTranscriptionCommand;
-const deserializeAws_restJson1StartStreamTranscriptionCommandError = async (output, context) => {
+exports.de_StartStreamTranscriptionCommand = de_StartStreamTranscriptionCommand;
+const de_StartStreamTranscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -339,19 +339,19 @@ const deserializeAws_restJson1StartStreamTranscriptionCommandError = async (outp
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribestreaming#BadRequestException":
-            throw await deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribestreaming#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribestreaming#InternalFailureException":
-            throw await deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribestreaming#LimitExceededException":
-            throw await deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ServiceUnavailableException":
         case "com.amazonaws.transcribestreaming#ServiceUnavailableException":
-            throw await deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             (0, smithy_client_1.throwDefaultError)({
@@ -363,7 +363,7 @@ const deserializeAws_restJson1StartStreamTranscriptionCommandError = async (outp
     }
 };
 const map = smithy_client_1.map;
-const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput, context) => {
+const de_BadRequestExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.Message != null) {
@@ -375,7 +375,7 @@ const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput,
     });
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
+const de_ConflictExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.Message != null) {
@@ -387,7 +387,7 @@ const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, c
     });
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1InternalFailureExceptionResponse = async (parsedOutput, context) => {
+const de_InternalFailureExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.Message != null) {
@@ -399,7 +399,7 @@ const deserializeAws_restJson1InternalFailureExceptionResponse = async (parsedOu
     });
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1LimitExceededExceptionResponse = async (parsedOutput, context) => {
+const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.Message != null) {
@@ -411,7 +411,7 @@ const deserializeAws_restJson1LimitExceededExceptionResponse = async (parsedOutp
     });
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parsedOutput, context) => {
+const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.Message != null) {
@@ -423,15 +423,15 @@ const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parse
     });
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
-const serializeAws_restJson1AudioStream = (input, context) => {
+const se_AudioStream = (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),
+        AudioEvent: (value) => se_AudioEvent_event(value, context),
+        ConfigurationEvent: (value) => se_ConfigurationEvent_event(value, context),
         _: (value) => value,
     });
     return context.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
 };
-const serializeAws_restJson1AudioEvent_event = (input, context) => {
+const se_AudioEvent_event = (input, context) => {
     const headers = {
         ":event-type": { type: "string", value: "AudioEvent" },
         ":message-type": { type: "string", value: "event" },
@@ -443,210 +443,210 @@ const serializeAws_restJson1AudioEvent_event = (input, context) => {
     }
     return { headers, body };
 };
-const serializeAws_restJson1ConfigurationEvent_event = (input, context) => {
+const se_ConfigurationEvent_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 = se_ConfigurationEvent(input, context);
     body = context.utf8Decoder(JSON.stringify(body));
     return { headers, body };
 };
-const deserializeAws_restJson1CallAnalyticsTranscriptResultStream = (output, context) => {
+const de_CallAnalyticsTranscriptResultStream = (output, context) => {
     return context.eventStreamMarshaller.deserialize(output, async (event) => {
         if (event["UtteranceEvent"] != null) {
             return {
-                UtteranceEvent: await deserializeAws_restJson1UtteranceEvent_event(event["UtteranceEvent"], context),
+                UtteranceEvent: await de_UtteranceEvent_event(event["UtteranceEvent"], context),
             };
         }
         if (event["CategoryEvent"] != null) {
             return {
-                CategoryEvent: await deserializeAws_restJson1CategoryEvent_event(event["CategoryEvent"], context),
+                CategoryEvent: await de_CategoryEvent_event(event["CategoryEvent"], context),
             };
         }
         if (event["BadRequestException"] != null) {
             return {
-                BadRequestException: await deserializeAws_restJson1BadRequestException_event(event["BadRequestException"], context),
+                BadRequestException: await de_BadRequestException_event(event["BadRequestException"], context),
             };
         }
         if (event["LimitExceededException"] != null) {
             return {
-                LimitExceededException: await deserializeAws_restJson1LimitExceededException_event(event["LimitExceededException"], context),
+                LimitExceededException: await de_LimitExceededException_event(event["LimitExceededException"], context),
             };
         }
         if (event["InternalFailureException"] != null) {
             return {
-                InternalFailureException: await deserializeAws_restJson1InternalFailureException_event(event["InternalFailureException"], context),
+                InternalFailureException: await de_InternalFailureException_event(event["InternalFailureException"], context),
             };
         }
         if (event["ConflictException"] != null) {
             return {
-                ConflictException: await deserializeAws_restJson1ConflictException_event(event["ConflictException"], context),
+                ConflictException: await de_ConflictException_event(event["ConflictException"], context),
             };
         }
         if (event["ServiceUnavailableException"] != null) {
             return {
-                ServiceUnavailableException: await deserializeAws_restJson1ServiceUnavailableException_event(event["ServiceUnavailableException"], context),
+                ServiceUnavailableException: await de_ServiceUnavailableException_event(event["ServiceUnavailableException"], context),
             };
         }
         return { $unknown: output };
     });
 };
-const deserializeAws_restJson1MedicalTranscriptResultStream = (output, context) => {
+const de_MedicalTranscriptResultStream = (output, context) => {
     return context.eventStreamMarshaller.deserialize(output, async (event) => {
         if (event["TranscriptEvent"] != null) {
             return {
-                TranscriptEvent: await deserializeAws_restJson1MedicalTranscriptEvent_event(event["TranscriptEvent"], context),
+                TranscriptEvent: await de_MedicalTranscriptEvent_event(event["TranscriptEvent"], context),
             };
         }
         if (event["BadRequestException"] != null) {
             return {
-                BadRequestException: await deserializeAws_restJson1BadRequestException_event(event["BadRequestException"], context),
+                BadRequestException: await de_BadRequestException_event(event["BadRequestException"], context),
             };
         }
         if (event["LimitExceededException"] != null) {
             return {
-                LimitExceededException: await deserializeAws_restJson1LimitExceededException_event(event["LimitExceededException"], context),
+                LimitExceededException: await de_LimitExceededException_event(event["LimitExceededException"], context),
             };
         }
         if (event["InternalFailureException"] != null) {
             return {
-                InternalFailureException: await deserializeAws_restJson1InternalFailureException_event(event["InternalFailureException"], context),
+                InternalFailureException: await de_InternalFailureException_event(event["InternalFailureException"], context),
             };
         }
         if (event["ConflictException"] != null) {
             return {
-                ConflictException: await deserializeAws_restJson1ConflictException_event(event["ConflictException"], context),
+                ConflictException: await de_ConflictException_event(event["ConflictException"], context),
             };
         }
         if (event["ServiceUnavailableException"] != null) {
             return {
-                ServiceUnavailableException: await deserializeAws_restJson1ServiceUnavailableException_event(event["ServiceUnavailableException"], context),
+                ServiceUnavailableException: await de_ServiceUnavailableException_event(event["ServiceUnavailableException"], context),
             };
         }
         return { $unknown: output };
     });
 };
-const deserializeAws_restJson1TranscriptResultStream = (output, context) => {
+const de_TranscriptResultStream = (output, context) => {
     return context.eventStreamMarshaller.deserialize(output, async (event) => {
         if (event["TranscriptEvent"] != null) {
             return {
-                TranscriptEvent: await deserializeAws_restJson1TranscriptEvent_event(event["TranscriptEvent"], context),
+                TranscriptEvent: await de_TranscriptEvent_event(event["TranscriptEvent"], context),
             };
         }
         if (event["BadRequestException"] != null) {
             return {
-                BadRequestException: await deserializeAws_restJson1BadRequestException_event(event["BadRequestException"], context),
+                BadRequestException: await de_BadRequestException_event(event["BadRequestException"], context),
             };
         }
         if (event["LimitExceededException"] != null) {
             return {
-                LimitExceededException: await deserializeAws_restJson1LimitExceededException_event(event["LimitExceededException"], context),
+                LimitExceededException: await de_LimitExceededException_event(event["LimitExceededException"], context),
             };
         }
         if (event["InternalFailureException"] != null) {
             return {
-                InternalFailureException: await deserializeAws_restJson1InternalFailureException_event(event["InternalFailureException"], context),
+                InternalFailureException: await de_InternalFailureException_event(event["InternalFailureException"], context),
             };
         }
         if (event["ConflictException"] != null) {
             return {
-                ConflictException: await deserializeAws_restJson1ConflictException_event(event["ConflictException"], context),
+                ConflictException: await de_ConflictException_event(event["ConflictException"], context),
             };
         }
         if (event["ServiceUnavailableException"] != null) {
             return {
-                ServiceUnavailableException: await deserializeAws_restJson1ServiceUnavailableException_event(event["ServiceUnavailableException"], context),
+                ServiceUnavailableException: await de_ServiceUnavailableException_event(event["ServiceUnavailableException"], context),
             };
         }
         return { $unknown: output };
     });
 };
-const deserializeAws_restJson1BadRequestException_event = async (output, context) => {
+const de_BadRequestException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
     };
-    return deserializeAws_restJson1BadRequestExceptionResponse(parsedOutput, context);
+    return de_BadRequestExceptionRes(parsedOutput, context);
 };
-const deserializeAws_restJson1CategoryEvent_event = async (output, context) => {
+const de_CategoryEvent_event = async (output, context) => {
     const contents = {};
     const data = await parseBody(output.body, context);
-    Object.assign(contents, deserializeAws_restJson1CategoryEvent(data, context));
+    Object.assign(contents, de_CategoryEvent(data, context));
     return contents;
 };
-const deserializeAws_restJson1ConflictException_event = async (output, context) => {
+const de_ConflictException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
     };
-    return deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+    return de_ConflictExceptionRes(parsedOutput, context);
 };
-const deserializeAws_restJson1InternalFailureException_event = async (output, context) => {
+const de_InternalFailureException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
     };
-    return deserializeAws_restJson1InternalFailureExceptionResponse(parsedOutput, context);
+    return de_InternalFailureExceptionRes(parsedOutput, context);
 };
-const deserializeAws_restJson1LimitExceededException_event = async (output, context) => {
+const de_LimitExceededException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
     };
-    return deserializeAws_restJson1LimitExceededExceptionResponse(parsedOutput, context);
+    return de_LimitExceededExceptionRes(parsedOutput, context);
 };
-const deserializeAws_restJson1MedicalTranscriptEvent_event = async (output, context) => {
+const de_MedicalTranscriptEvent_event = async (output, context) => {
     const contents = {};
     const data = await parseBody(output.body, context);
-    Object.assign(contents, deserializeAws_restJson1MedicalTranscriptEvent(data, context));
+    Object.assign(contents, de_MedicalTranscriptEvent(data, context));
     return contents;
 };
-const deserializeAws_restJson1ServiceUnavailableException_event = async (output, context) => {
+const de_ServiceUnavailableException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
     };
-    return deserializeAws_restJson1ServiceUnavailableExceptionResponse(parsedOutput, context);
+    return de_ServiceUnavailableExceptionRes(parsedOutput, context);
 };
-const deserializeAws_restJson1TranscriptEvent_event = async (output, context) => {
+const de_TranscriptEvent_event = async (output, context) => {
     const contents = {};
     const data = await parseBody(output.body, context);
-    Object.assign(contents, deserializeAws_restJson1TranscriptEvent(data, context));
+    Object.assign(contents, de_TranscriptEvent(data, context));
     return contents;
 };
-const deserializeAws_restJson1UtteranceEvent_event = async (output, context) => {
+const de_UtteranceEvent_event = async (output, context) => {
     const contents = {};
     const data = await parseBody(output.body, context);
-    Object.assign(contents, deserializeAws_restJson1UtteranceEvent(data, context));
+    Object.assign(contents, de_UtteranceEvent(data, context));
     return contents;
 };
-const serializeAws_restJson1ChannelDefinition = (input, context) => {
+const se_ChannelDefinition = (input, context) => {
     return {
         ...(input.ChannelId != null && { ChannelId: input.ChannelId }),
         ...(input.ParticipantRole != null && { ParticipantRole: input.ParticipantRole }),
     };
 };
-const serializeAws_restJson1ChannelDefinitions = (input, context) => {
+const se_ChannelDefinitions = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1ChannelDefinition(entry, context);
+        return se_ChannelDefinition(entry, context);
     });
 };
-const serializeAws_restJson1ConfigurationEvent = (input, context) => {
+const se_ConfigurationEvent = (input, context) => {
     return {
         ...(input.ChannelDefinitions != null && {
-            ChannelDefinitions: serializeAws_restJson1ChannelDefinitions(input.ChannelDefinitions, context),
+            ChannelDefinitions: se_ChannelDefinitions(input.ChannelDefinitions, context),
         }),
         ...(input.PostCallAnalyticsSettings != null && {
-            PostCallAnalyticsSettings: serializeAws_restJson1PostCallAnalyticsSettings(input.PostCallAnalyticsSettings, context),
+            PostCallAnalyticsSettings: se_PostCallAnalyticsSettings(input.PostCallAnalyticsSettings, context),
         }),
     };
 };
-const serializeAws_restJson1PostCallAnalyticsSettings = (input, context) => {
+const se_PostCallAnalyticsSettings = (input, context) => {
     return {
         ...(input.ContentRedactionOutput != null && { ContentRedactionOutput: input.ContentRedactionOutput }),
         ...(input.DataAccessRoleArn != null && { DataAccessRoleArn: input.DataAccessRoleArn }),
@@ -654,25 +654,25 @@ const serializeAws_restJson1PostCallAnalyticsSettings = (input, context) => {
         ...(input.OutputLocation != null && { OutputLocation: input.OutputLocation }),
     };
 };
-const deserializeAws_restJson1Alternative = (output, context) => {
+const de_Alternative = (output, context) => {
     return {
-        Entities: output.Entities != null ? deserializeAws_restJson1EntityList(output.Entities, context) : undefined,
-        Items: output.Items != null ? deserializeAws_restJson1ItemList(output.Items, context) : undefined,
+        Entities: output.Entities != null ? de_EntityList(output.Entities, context) : undefined,
+        Items: output.Items != null ? de_ItemList(output.Items, context) : undefined,
         Transcript: (0, smithy_client_1.expectString)(output.Transcript),
     };
 };
-const deserializeAws_restJson1AlternativeList = (output, context) => {
+const de_AlternativeList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Alternative(entry, context);
+        return de_Alternative(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1CallAnalyticsEntity = (output, context) => {
+const de_CallAnalyticsEntity = (output, context) => {
     return {
         BeginOffsetMillis: (0, smithy_client_1.expectLong)(output.BeginOffsetMillis),
         Category: (0, smithy_client_1.expectString)(output.Category),
@@ -682,18 +682,18 @@ const deserializeAws_restJson1CallAnalyticsEntity = (output, context) => {
         Type: (0, smithy_client_1.expectString)(output.Type),
     };
 };
-const deserializeAws_restJson1CallAnalyticsEntityList = (output, context) => {
+const de_CallAnalyticsEntityList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1CallAnalyticsEntity(entry, context);
+        return de_CallAnalyticsEntity(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1CallAnalyticsItem = (output, context) => {
+const de_CallAnalyticsItem = (output, context) => {
     return {
         BeginOffsetMillis: (0, smithy_client_1.expectLong)(output.BeginOffsetMillis),
         Confidence: (0, smithy_client_1.limitedParseDouble)(output.Confidence),
@@ -704,34 +704,30 @@ const deserializeAws_restJson1CallAnalyticsItem = (output, context) => {
         VocabularyFilterMatch: (0, smithy_client_1.expectBoolean)(output.VocabularyFilterMatch),
     };
 };
-const deserializeAws_restJson1CallAnalyticsItemList = (output, context) => {
+const de_CallAnalyticsItemList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1CallAnalyticsItem(entry, context);
+        return de_CallAnalyticsItem(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1CategoryEvent = (output, context) => {
+const de_CategoryEvent = (output, context) => {
     return {
-        MatchedCategories: output.MatchedCategories != null
-            ? deserializeAws_restJson1StringList(output.MatchedCategories, context)
-            : undefined,
-        MatchedDetails: output.MatchedDetails != null
-            ? deserializeAws_restJson1MatchedCategoryDetails(output.MatchedDetails, context)
-            : undefined,
+        MatchedCategories: output.MatchedCategories != null ? de_StringList(output.MatchedCategories, context) : undefined,
+        MatchedDetails: output.MatchedDetails != null ? de_MatchedCategoryDetails(output.MatchedDetails, context) : undefined,
     };
 };
-const deserializeAws_restJson1CharacterOffsets = (output, context) => {
+const de_CharacterOffsets = (output, context) => {
     return {
         Begin: (0, smithy_client_1.expectInt32)(output.Begin),
         End: (0, smithy_client_1.expectInt32)(output.End),
     };
 };
-const deserializeAws_restJson1Entity = (output, context) => {
+const de_Entity = (output, context) => {
     return {
         Category: (0, smithy_client_1.expectString)(output.Category),
         Confidence: (0, smithy_client_1.limitedParseDouble)(output.Confidence),
@@ -741,36 +737,34 @@ const deserializeAws_restJson1Entity = (output, context) => {
         Type: (0, smithy_client_1.expectString)(output.Type),
     };
 };
-const deserializeAws_restJson1EntityList = (output, context) => {
+const de_EntityList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Entity(entry, context);
+        return de_Entity(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1IssueDetected = (output, context) => {
+const de_IssueDetected = (output, context) => {
     return {
-        CharacterOffsets: output.CharacterOffsets != null
-            ? deserializeAws_restJson1CharacterOffsets(output.CharacterOffsets, context)
-            : undefined,
+        CharacterOffsets: output.CharacterOffsets != null ? de_CharacterOffsets(output.CharacterOffsets, context) : undefined,
     };
 };
-const deserializeAws_restJson1IssuesDetected = (output, context) => {
+const de_IssuesDetected = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1IssueDetected(entry, context);
+        return de_IssueDetected(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1Item = (output, context) => {
+const de_Item = (output, context) => {
     return {
         Confidence: (0, smithy_client_1.limitedParseDouble)(output.Confidence),
         Content: (0, smithy_client_1.expectString)(output.Content),
@@ -782,62 +776,62 @@ const deserializeAws_restJson1Item = (output, context) => {
         VocabularyFilterMatch: (0, smithy_client_1.expectBoolean)(output.VocabularyFilterMatch),
     };
 };
-const deserializeAws_restJson1ItemList = (output, context) => {
+const de_ItemList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Item(entry, context);
+        return de_Item(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1LanguageIdentification = (output, context) => {
+const de_LanguageIdentification = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1LanguageWithScore(entry, context);
+        return de_LanguageWithScore(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1LanguageWithScore = (output, context) => {
+const de_LanguageWithScore = (output, context) => {
     return {
         LanguageCode: (0, smithy_client_1.expectString)(output.LanguageCode),
         Score: (0, smithy_client_1.limitedParseDouble)(output.Score),
     };
 };
-const deserializeAws_restJson1MatchedCategoryDetails = (output, context) => {
+const de_MatchedCategoryDetails = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = deserializeAws_restJson1PointsOfInterest(value, context);
+        acc[key] = de_PointsOfInterest(value, context);
         return acc;
     }, {});
 };
-const deserializeAws_restJson1MedicalAlternative = (output, context) => {
+const de_MedicalAlternative = (output, context) => {
     return {
-        Entities: output.Entities != null ? deserializeAws_restJson1MedicalEntityList(output.Entities, context) : undefined,
-        Items: output.Items != null ? deserializeAws_restJson1MedicalItemList(output.Items, context) : undefined,
+        Entities: output.Entities != null ? de_MedicalEntityList(output.Entities, context) : undefined,
+        Items: output.Items != null ? de_MedicalItemList(output.Items, context) : undefined,
         Transcript: (0, smithy_client_1.expectString)(output.Transcript),
     };
 };
-const deserializeAws_restJson1MedicalAlternativeList = (output, context) => {
+const de_MedicalAlternativeList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1MedicalAlternative(entry, context);
+        return de_MedicalAlternative(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1MedicalEntity = (output, context) => {
+const de_MedicalEntity = (output, context) => {
     return {
         Category: (0, smithy_client_1.expectString)(output.Category),
         Confidence: (0, smithy_client_1.limitedParseDouble)(output.Confidence),
@@ -846,18 +840,18 @@ const deserializeAws_restJson1MedicalEntity = (output, context) => {
         StartTime: (0, smithy_client_1.limitedParseDouble)(output.StartTime),
     };
 };
-const deserializeAws_restJson1MedicalEntityList = (output, context) => {
+const de_MedicalEntityList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1MedicalEntity(entry, context);
+        return de_MedicalEntity(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1MedicalItem = (output, context) => {
+const de_MedicalItem = (output, context) => {
     return {
         Confidence: (0, smithy_client_1.limitedParseDouble)(output.Confidence),
         Content: (0, smithy_client_1.expectString)(output.Content),
@@ -867,22 +861,20 @@ const deserializeAws_restJson1MedicalItem = (output, context) => {
         Type: (0, smithy_client_1.expectString)(output.Type),
     };
 };
-const deserializeAws_restJson1MedicalItemList = (output, context) => {
+const de_MedicalItemList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1MedicalItem(entry, context);
+        return de_MedicalItem(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1MedicalResult = (output, context) => {
+const de_MedicalResult = (output, context) => {
     return {
-        Alternatives: output.Alternatives != null
-            ? deserializeAws_restJson1MedicalAlternativeList(output.Alternatives, context)
-            : undefined,
+        Alternatives: output.Alternatives != null ? de_MedicalAlternativeList(output.Alternatives, context) : undefined,
         ChannelId: (0, smithy_client_1.expectString)(output.ChannelId),
         EndTime: (0, smithy_client_1.limitedParseDouble)(output.EndTime),
         IsPartial: (0, smithy_client_1.expectBoolean)(output.IsPartial),
@@ -890,60 +882,58 @@ const deserializeAws_restJson1MedicalResult = (output, context) => {
         StartTime: (0, smithy_client_1.limitedParseDouble)(output.StartTime),
     };
 };
-const deserializeAws_restJson1MedicalResultList = (output, context) => {
+const de_MedicalResultList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1MedicalResult(entry, context);
+        return de_MedicalResult(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1MedicalTranscript = (output, context) => {
+const de_MedicalTranscript = (output, context) => {
     return {
-        Results: output.Results != null ? deserializeAws_restJson1MedicalResultList(output.Results, context) : undefined,
+        Results: output.Results != null ? de_MedicalResultList(output.Results, context) : undefined,
     };
 };
-const deserializeAws_restJson1MedicalTranscriptEvent = (output, context) => {
+const de_MedicalTranscriptEvent = (output, context) => {
     return {
-        Transcript: output.Transcript != null ? deserializeAws_restJson1MedicalTranscript(output.Transcript, context) : undefined,
+        Transcript: output.Transcript != null ? de_MedicalTranscript(output.Transcript, context) : undefined,
     };
 };
-const deserializeAws_restJson1PointsOfInterest = (output, context) => {
+const de_PointsOfInterest = (output, context) => {
     return {
-        TimestampRanges: output.TimestampRanges != null
-            ? deserializeAws_restJson1TimestampRanges(output.TimestampRanges, context)
-            : undefined,
+        TimestampRanges: output.TimestampRanges != null ? de_TimestampRanges(output.TimestampRanges, context) : undefined,
     };
 };
-const deserializeAws_restJson1Result = (output, context) => {
+const de_Result = (output, context) => {
     return {
-        Alternatives: output.Alternatives != null ? deserializeAws_restJson1AlternativeList(output.Alternatives, context) : undefined,
+        Alternatives: output.Alternatives != null ? de_AlternativeList(output.Alternatives, context) : undefined,
         ChannelId: (0, smithy_client_1.expectString)(output.ChannelId),
         EndTime: (0, smithy_client_1.limitedParseDouble)(output.EndTime),
         IsPartial: (0, smithy_client_1.expectBoolean)(output.IsPartial),
         LanguageCode: (0, smithy_client_1.expectString)(output.LanguageCode),
         LanguageIdentification: output.LanguageIdentification != null
-            ? deserializeAws_restJson1LanguageIdentification(output.LanguageIdentification, context)
+            ? de_LanguageIdentification(output.LanguageIdentification, context)
             : undefined,
         ResultId: (0, smithy_client_1.expectString)(output.ResultId),
         StartTime: (0, smithy_client_1.limitedParseDouble)(output.StartTime),
     };
 };
-const deserializeAws_restJson1ResultList = (output, context) => {
+const de_ResultList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Result(entry, context);
+        return de_Result(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1StringList = (output, context) => {
+const de_StringList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -954,43 +944,41 @@ const deserializeAws_restJson1StringList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1TimestampRange = (output, context) => {
+const de_TimestampRange = (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 de_TimestampRanges = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1TimestampRange(entry, context);
+        return de_TimestampRange(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1Transcript = (output, context) => {
+const de_Transcript = (output, context) => {
     return {
-        Results: output.Results != null ? deserializeAws_restJson1ResultList(output.Results, context) : undefined,
+        Results: output.Results != null ? de_ResultList(output.Results, context) : undefined,
     };
 };
-const deserializeAws_restJson1TranscriptEvent = (output, context) => {
+const de_TranscriptEvent = (output, context) => {
     return {
-        Transcript: output.Transcript != null ? deserializeAws_restJson1Transcript(output.Transcript, context) : undefined,
+        Transcript: output.Transcript != null ? de_Transcript(output.Transcript, context) : undefined,
     };
 };
-const deserializeAws_restJson1UtteranceEvent = (output, context) => {
+const de_UtteranceEvent = (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,
+        Entities: output.Entities != null ? de_CallAnalyticsEntityList(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,
+        IssuesDetected: output.IssuesDetected != null ? de_IssuesDetected(output.IssuesDetected, context) : undefined,
+        Items: output.Items != null ? de_CallAnalyticsItemList(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),