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

package/dist-es/protocols/Aws_restJson1.js

@@ -2,7 +2,7 @@ import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 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) => {
+export 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,
@@ -28,7 +28,7 @@ export const serializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand
     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 __HttpRequest({
         protocol,
@@ -40,7 +40,7 @@ export const serializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand
         body,
     });
 };
-export const serializeAws_restJson1StartMedicalStreamTranscriptionCommand = async (input, context) => {
+export 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,
@@ -70,7 +70,7 @@ export const serializeAws_restJson1StartMedicalStreamTranscriptionCommand = asyn
     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 __HttpRequest({
         protocol,
@@ -82,7 +82,7 @@ export const serializeAws_restJson1StartMedicalStreamTranscriptionCommand = asyn
         body,
     });
 };
-export const serializeAws_restJson1StartStreamTranscriptionCommand = async (input, context) => {
+export 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,
@@ -128,7 +128,7 @@ export const serializeAws_restJson1StartStreamTranscriptionCommand = async (inpu
     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 __HttpRequest({
         protocol,
@@ -140,9 +140,9 @@ export const serializeAws_restJson1StartStreamTranscriptionCommand = async (inpu
         body,
     });
 };
-export const deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommand = async (output, context) => {
+export 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),
@@ -168,10 +168,10 @@ export const deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionComman
         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;
 };
-const deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommandError = async (output, context) => {
+const de_StartCallAnalyticsStreamTranscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -180,19 +180,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;
             throwDefaultError({
@@ -203,9 +203,9 @@ const deserializeAws_restJson1StartCallAnalyticsStreamTranscriptionCommandError
             });
     }
 };
-export const deserializeAws_restJson1StartMedicalStreamTranscriptionCommand = async (output, context) => {
+export 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),
@@ -235,10 +235,10 @@ export const deserializeAws_restJson1StartMedicalStreamTranscriptionCommand = as
         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;
 };
-const deserializeAws_restJson1StartMedicalStreamTranscriptionCommandError = async (output, context) => {
+const de_StartMedicalStreamTranscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -247,19 +247,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;
             throwDefaultError({
@@ -270,9 +270,9 @@ const deserializeAws_restJson1StartMedicalStreamTranscriptionCommandError = asyn
             });
     }
 };
-export const deserializeAws_restJson1StartStreamTranscriptionCommand = async (output, context) => {
+export 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),
@@ -318,10 +318,10 @@ export const deserializeAws_restJson1StartStreamTranscriptionCommand = async (ou
         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;
 };
-const deserializeAws_restJson1StartStreamTranscriptionCommandError = async (output, context) => {
+const de_StartStreamTranscriptionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -330,19 +330,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;
             throwDefaultError({
@@ -354,7 +354,7 @@ const deserializeAws_restJson1StartStreamTranscriptionCommandError = async (outp
     }
 };
 const map = __map;
-const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput, context) => {
+const de_BadRequestExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.Message != null) {
@@ -366,7 +366,7 @@ const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput,
     });
     return __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) {
@@ -378,7 +378,7 @@ const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, c
     });
     return __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) {
@@ -390,7 +390,7 @@ const deserializeAws_restJson1InternalFailureExceptionResponse = async (parsedOu
     });
     return __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) {
@@ -402,7 +402,7 @@ const deserializeAws_restJson1LimitExceededExceptionResponse = async (parsedOutp
     });
     return __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) {
@@ -414,15 +414,15 @@ const deserializeAws_restJson1ServiceUnavailableExceptionResponse = async (parse
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const serializeAws_restJson1AudioStream = (input, context) => {
+const se_AudioStream = (input, context) => {
     const eventMarshallingVisitor = (event) => 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" },
@@ -434,210 +434,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 }),
@@ -645,25 +645,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: __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: __expectLong(output.BeginOffsetMillis),
         Category: __expectString(output.Category),
@@ -673,18 +673,18 @@ const deserializeAws_restJson1CallAnalyticsEntity = (output, context) => {
         Type: __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: __expectLong(output.BeginOffsetMillis),
         Confidence: __limitedParseDouble(output.Confidence),
@@ -695,34 +695,30 @@ const deserializeAws_restJson1CallAnalyticsItem = (output, context) => {
         VocabularyFilterMatch: __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: __expectInt32(output.Begin),
         End: __expectInt32(output.End),
     };
 };
-const deserializeAws_restJson1Entity = (output, context) => {
+const de_Entity = (output, context) => {
     return {
         Category: __expectString(output.Category),
         Confidence: __limitedParseDouble(output.Confidence),
@@ -732,36 +728,34 @@ const deserializeAws_restJson1Entity = (output, context) => {
         Type: __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: __limitedParseDouble(output.Confidence),
         Content: __expectString(output.Content),
@@ -773,62 +767,62 @@ const deserializeAws_restJson1Item = (output, context) => {
         VocabularyFilterMatch: __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: __expectString(output.LanguageCode),
         Score: __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: __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: __expectString(output.Category),
         Confidence: __limitedParseDouble(output.Confidence),
@@ -837,18 +831,18 @@ const deserializeAws_restJson1MedicalEntity = (output, context) => {
         StartTime: __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: __limitedParseDouble(output.Confidence),
         Content: __expectString(output.Content),
@@ -858,22 +852,20 @@ const deserializeAws_restJson1MedicalItem = (output, context) => {
         Type: __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: __expectString(output.ChannelId),
         EndTime: __limitedParseDouble(output.EndTime),
         IsPartial: __expectBoolean(output.IsPartial),
@@ -881,60 +873,58 @@ const deserializeAws_restJson1MedicalResult = (output, context) => {
         StartTime: __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: __expectString(output.ChannelId),
         EndTime: __limitedParseDouble(output.EndTime),
         IsPartial: __expectBoolean(output.IsPartial),
         LanguageCode: __expectString(output.LanguageCode),
         LanguageIdentification: output.LanguageIdentification != null
-            ? deserializeAws_restJson1LanguageIdentification(output.LanguageIdentification, context)
+            ? de_LanguageIdentification(output.LanguageIdentification, context)
             : undefined,
         ResultId: __expectString(output.ResultId),
         StartTime: __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) => {
@@ -945,43 +935,41 @@ const deserializeAws_restJson1StringList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1TimestampRange = (output, context) => {
+const de_TimestampRange = (output, context) => {
     return {
         BeginOffsetMillis: __expectLong(output.BeginOffsetMillis),
         EndOffsetMillis: __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: __expectLong(output.BeginOffsetMillis),
         EndOffsetMillis: __expectLong(output.EndOffsetMillis),
-        Entities: output.Entities != null ? deserializeAws_restJson1CallAnalyticsEntityList(output.Entities, context) : undefined,
+        Entities: output.Entities != null ? de_CallAnalyticsEntityList(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,
+        IssuesDetected: output.IssuesDetected != null ? de_IssuesDetected(output.IssuesDetected, context) : undefined,
+        Items: output.Items != null ? de_CallAnalyticsItemList(output.Items, context) : undefined,
         ParticipantRole: __expectString(output.ParticipantRole),
         Sentiment: __expectString(output.Sentiment),
         Transcript: __expectString(output.Transcript),