@aws-sdk/client-transcribe 3.303.0 → 3.309.0

package/dist-es/protocols/Aws_json1_1.js

@@ -2,371 +2,371 @@ import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, expectUnion as __expectUnion, limitedParseFloat32 as __limitedParseFloat32, parseEpochTimestamp as __parseEpochTimestamp, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { BadRequestException, ConflictException, InternalFailureException, LimitExceededException, NotFoundException, Rule, } from "../models/models_0";
 import { TranscribeServiceException as __BaseException } from "../models/TranscribeServiceException";
-export const serializeAws_json1_1CreateCallAnalyticsCategoryCommand = async (input, context) => {
+export const se_CreateCallAnalyticsCategoryCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.CreateCallAnalyticsCategory",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateCallAnalyticsCategoryRequest(input, context));
+    body = JSON.stringify(se_CreateCallAnalyticsCategoryRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateLanguageModelCommand = async (input, context) => {
+export const se_CreateLanguageModelCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.CreateLanguageModel",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateLanguageModelRequest(input, context));
+    body = JSON.stringify(se_CreateLanguageModelRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateMedicalVocabularyCommand = async (input, context) => {
+export const se_CreateMedicalVocabularyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.CreateMedicalVocabulary",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateMedicalVocabularyRequest(input, context));
+    body = JSON.stringify(se_CreateMedicalVocabularyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateVocabularyCommand = async (input, context) => {
+export const se_CreateVocabularyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.CreateVocabulary",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateVocabularyRequest(input, context));
+    body = JSON.stringify(se_CreateVocabularyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateVocabularyFilterCommand = async (input, context) => {
+export const se_CreateVocabularyFilterCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.CreateVocabularyFilter",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateVocabularyFilterRequest(input, context));
+    body = JSON.stringify(se_CreateVocabularyFilterRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteCallAnalyticsCategoryCommand = async (input, context) => {
+export const se_DeleteCallAnalyticsCategoryCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.DeleteCallAnalyticsCategory",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteCallAnalyticsCategoryRequest(input, context));
+    body = JSON.stringify(se_DeleteCallAnalyticsCategoryRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteCallAnalyticsJobCommand = async (input, context) => {
+export const se_DeleteCallAnalyticsJobCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.DeleteCallAnalyticsJob",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteCallAnalyticsJobRequest(input, context));
+    body = JSON.stringify(se_DeleteCallAnalyticsJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteLanguageModelCommand = async (input, context) => {
+export const se_DeleteLanguageModelCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.DeleteLanguageModel",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteLanguageModelRequest(input, context));
+    body = JSON.stringify(se_DeleteLanguageModelRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteMedicalTranscriptionJobCommand = async (input, context) => {
+export const se_DeleteMedicalTranscriptionJobCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.DeleteMedicalTranscriptionJob",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteMedicalTranscriptionJobRequest(input, context));
+    body = JSON.stringify(se_DeleteMedicalTranscriptionJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteMedicalVocabularyCommand = async (input, context) => {
+export const se_DeleteMedicalVocabularyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.DeleteMedicalVocabulary",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteMedicalVocabularyRequest(input, context));
+    body = JSON.stringify(se_DeleteMedicalVocabularyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteTranscriptionJobCommand = async (input, context) => {
+export const se_DeleteTranscriptionJobCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.DeleteTranscriptionJob",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteTranscriptionJobRequest(input, context));
+    body = JSON.stringify(se_DeleteTranscriptionJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteVocabularyCommand = async (input, context) => {
+export const se_DeleteVocabularyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.DeleteVocabulary",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteVocabularyRequest(input, context));
+    body = JSON.stringify(se_DeleteVocabularyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteVocabularyFilterCommand = async (input, context) => {
+export const se_DeleteVocabularyFilterCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.DeleteVocabularyFilter",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteVocabularyFilterRequest(input, context));
+    body = JSON.stringify(se_DeleteVocabularyFilterRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeLanguageModelCommand = async (input, context) => {
+export const se_DescribeLanguageModelCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.DescribeLanguageModel",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeLanguageModelRequest(input, context));
+    body = JSON.stringify(se_DescribeLanguageModelRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetCallAnalyticsCategoryCommand = async (input, context) => {
+export const se_GetCallAnalyticsCategoryCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.GetCallAnalyticsCategory",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetCallAnalyticsCategoryRequest(input, context));
+    body = JSON.stringify(se_GetCallAnalyticsCategoryRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetCallAnalyticsJobCommand = async (input, context) => {
+export const se_GetCallAnalyticsJobCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.GetCallAnalyticsJob",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetCallAnalyticsJobRequest(input, context));
+    body = JSON.stringify(se_GetCallAnalyticsJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetMedicalTranscriptionJobCommand = async (input, context) => {
+export const se_GetMedicalTranscriptionJobCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.GetMedicalTranscriptionJob",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetMedicalTranscriptionJobRequest(input, context));
+    body = JSON.stringify(se_GetMedicalTranscriptionJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetMedicalVocabularyCommand = async (input, context) => {
+export const se_GetMedicalVocabularyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.GetMedicalVocabulary",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetMedicalVocabularyRequest(input, context));
+    body = JSON.stringify(se_GetMedicalVocabularyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetTranscriptionJobCommand = async (input, context) => {
+export const se_GetTranscriptionJobCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.GetTranscriptionJob",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetTranscriptionJobRequest(input, context));
+    body = JSON.stringify(se_GetTranscriptionJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetVocabularyCommand = async (input, context) => {
+export const se_GetVocabularyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.GetVocabulary",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetVocabularyRequest(input, context));
+    body = JSON.stringify(se_GetVocabularyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetVocabularyFilterCommand = async (input, context) => {
+export const se_GetVocabularyFilterCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.GetVocabularyFilter",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetVocabularyFilterRequest(input, context));
+    body = JSON.stringify(se_GetVocabularyFilterRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListCallAnalyticsCategoriesCommand = async (input, context) => {
+export const se_ListCallAnalyticsCategoriesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.ListCallAnalyticsCategories",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListCallAnalyticsCategoriesRequest(input, context));
+    body = JSON.stringify(se_ListCallAnalyticsCategoriesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListCallAnalyticsJobsCommand = async (input, context) => {
+export const se_ListCallAnalyticsJobsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.ListCallAnalyticsJobs",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListCallAnalyticsJobsRequest(input, context));
+    body = JSON.stringify(se_ListCallAnalyticsJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListLanguageModelsCommand = async (input, context) => {
+export const se_ListLanguageModelsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.ListLanguageModels",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListLanguageModelsRequest(input, context));
+    body = JSON.stringify(se_ListLanguageModelsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListMedicalTranscriptionJobsCommand = async (input, context) => {
+export const se_ListMedicalTranscriptionJobsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.ListMedicalTranscriptionJobs",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListMedicalTranscriptionJobsRequest(input, context));
+    body = JSON.stringify(se_ListMedicalTranscriptionJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListMedicalVocabulariesCommand = async (input, context) => {
+export const se_ListMedicalVocabulariesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.ListMedicalVocabularies",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListMedicalVocabulariesRequest(input, context));
+    body = JSON.stringify(se_ListMedicalVocabulariesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListTagsForResourceCommand = async (input, context) => {
+export const se_ListTagsForResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.ListTagsForResource",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListTagsForResourceRequest(input, context));
+    body = JSON.stringify(se_ListTagsForResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListTranscriptionJobsCommand = async (input, context) => {
+export const se_ListTranscriptionJobsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.ListTranscriptionJobs",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListTranscriptionJobsRequest(input, context));
+    body = JSON.stringify(se_ListTranscriptionJobsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListVocabulariesCommand = async (input, context) => {
+export const se_ListVocabulariesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.ListVocabularies",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListVocabulariesRequest(input, context));
+    body = JSON.stringify(se_ListVocabulariesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListVocabularyFiltersCommand = async (input, context) => {
+export const se_ListVocabularyFiltersCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.ListVocabularyFilters",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListVocabularyFiltersRequest(input, context));
+    body = JSON.stringify(se_ListVocabularyFiltersRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1StartCallAnalyticsJobCommand = async (input, context) => {
+export const se_StartCallAnalyticsJobCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.StartCallAnalyticsJob",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1StartCallAnalyticsJobRequest(input, context));
+    body = JSON.stringify(se_StartCallAnalyticsJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1StartMedicalTranscriptionJobCommand = async (input, context) => {
+export const se_StartMedicalTranscriptionJobCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.StartMedicalTranscriptionJob",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1StartMedicalTranscriptionJobRequest(input, context));
+    body = JSON.stringify(se_StartMedicalTranscriptionJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1StartTranscriptionJobCommand = async (input, context) => {
+export const se_StartTranscriptionJobCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.StartTranscriptionJob",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1StartTranscriptionJobRequest(input, context));
+    body = JSON.stringify(se_StartTranscriptionJobRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1TagResourceCommand = async (input, context) => {
+export const se_TagResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.TagResource",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1TagResourceRequest(input, context));
+    body = JSON.stringify(se_TagResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UntagResourceCommand = async (input, context) => {
+export const se_UntagResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.UntagResource",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UntagResourceRequest(input, context));
+    body = JSON.stringify(se_UntagResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UpdateCallAnalyticsCategoryCommand = async (input, context) => {
+export const se_UpdateCallAnalyticsCategoryCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.UpdateCallAnalyticsCategory",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UpdateCallAnalyticsCategoryRequest(input, context));
+    body = JSON.stringify(se_UpdateCallAnalyticsCategoryRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UpdateMedicalVocabularyCommand = async (input, context) => {
+export const se_UpdateMedicalVocabularyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.UpdateMedicalVocabulary",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UpdateMedicalVocabularyRequest(input, context));
+    body = JSON.stringify(se_UpdateMedicalVocabularyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UpdateVocabularyCommand = async (input, context) => {
+export const se_UpdateVocabularyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.UpdateVocabulary",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UpdateVocabularyRequest(input, context));
+    body = JSON.stringify(se_UpdateVocabularyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UpdateVocabularyFilterCommand = async (input, context) => {
+export const se_UpdateVocabularyFilterCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "Transcribe.UpdateVocabularyFilter",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UpdateVocabularyFilterRequest(input, context));
+    body = JSON.stringify(se_UpdateVocabularyFilterRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const deserializeAws_json1_1CreateCallAnalyticsCategoryCommand = async (output, context) => {
+export const de_CreateCallAnalyticsCategoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateCallAnalyticsCategoryCommandError(output, context);
+        return de_CreateCallAnalyticsCategoryCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreateCallAnalyticsCategoryResponse(data, context);
+    contents = de_CreateCallAnalyticsCategoryResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateCallAnalyticsCategoryCommandError = async (output, context) => {
+const de_CreateCallAnalyticsCategoryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -375,16 +375,16 @@ const deserializeAws_json1_1CreateCallAnalyticsCategoryCommandError = async (out
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribe#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -395,20 +395,20 @@ const deserializeAws_json1_1CreateCallAnalyticsCategoryCommandError = async (out
             });
     }
 };
-export const deserializeAws_json1_1CreateLanguageModelCommand = async (output, context) => {
+export const de_CreateLanguageModelCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateLanguageModelCommandError(output, context);
+        return de_CreateLanguageModelCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreateLanguageModelResponse(data, context);
+    contents = de_CreateLanguageModelResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateLanguageModelCommandError = async (output, context) => {
+const de_CreateLanguageModelCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -417,16 +417,16 @@ const deserializeAws_json1_1CreateLanguageModelCommandError = async (output, con
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribe#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -437,20 +437,20 @@ const deserializeAws_json1_1CreateLanguageModelCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1CreateMedicalVocabularyCommand = async (output, context) => {
+export const de_CreateMedicalVocabularyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateMedicalVocabularyCommandError(output, context);
+        return de_CreateMedicalVocabularyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreateMedicalVocabularyResponse(data, context);
+    contents = de_CreateMedicalVocabularyResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateMedicalVocabularyCommandError = async (output, context) => {
+const de_CreateMedicalVocabularyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -459,16 +459,16 @@ const deserializeAws_json1_1CreateMedicalVocabularyCommandError = async (output,
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribe#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -479,20 +479,20 @@ const deserializeAws_json1_1CreateMedicalVocabularyCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1CreateVocabularyCommand = async (output, context) => {
+export const de_CreateVocabularyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateVocabularyCommandError(output, context);
+        return de_CreateVocabularyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreateVocabularyResponse(data, context);
+    contents = de_CreateVocabularyResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateVocabularyCommandError = async (output, context) => {
+const de_CreateVocabularyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -501,16 +501,16 @@ const deserializeAws_json1_1CreateVocabularyCommandError = async (output, contex
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribe#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -521,20 +521,20 @@ const deserializeAws_json1_1CreateVocabularyCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1CreateVocabularyFilterCommand = async (output, context) => {
+export const de_CreateVocabularyFilterCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateVocabularyFilterCommandError(output, context);
+        return de_CreateVocabularyFilterCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreateVocabularyFilterResponse(data, context);
+    contents = de_CreateVocabularyFilterResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateVocabularyFilterCommandError = async (output, context) => {
+const de_CreateVocabularyFilterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -543,16 +543,16 @@ const deserializeAws_json1_1CreateVocabularyFilterCommandError = async (output,
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribe#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -563,20 +563,20 @@ const deserializeAws_json1_1CreateVocabularyFilterCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1DeleteCallAnalyticsCategoryCommand = async (output, context) => {
+export const de_DeleteCallAnalyticsCategoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteCallAnalyticsCategoryCommandError(output, context);
+        return de_DeleteCallAnalyticsCategoryCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DeleteCallAnalyticsCategoryResponse(data, context);
+    contents = de_DeleteCallAnalyticsCategoryResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteCallAnalyticsCategoryCommandError = async (output, context) => {
+const de_DeleteCallAnalyticsCategoryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -585,16 +585,16 @@ const deserializeAws_json1_1DeleteCallAnalyticsCategoryCommandError = async (out
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -605,20 +605,20 @@ const deserializeAws_json1_1DeleteCallAnalyticsCategoryCommandError = async (out
             });
     }
 };
-export const deserializeAws_json1_1DeleteCallAnalyticsJobCommand = async (output, context) => {
+export const de_DeleteCallAnalyticsJobCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteCallAnalyticsJobCommandError(output, context);
+        return de_DeleteCallAnalyticsJobCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DeleteCallAnalyticsJobResponse(data, context);
+    contents = de_DeleteCallAnalyticsJobResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteCallAnalyticsJobCommandError = async (output, context) => {
+const de_DeleteCallAnalyticsJobCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -627,13 +627,13 @@ const deserializeAws_json1_1DeleteCallAnalyticsJobCommandError = async (output,
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -644,9 +644,9 @@ const deserializeAws_json1_1DeleteCallAnalyticsJobCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1DeleteLanguageModelCommand = async (output, context) => {
+export const de_DeleteLanguageModelCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteLanguageModelCommandError(output, context);
+        return de_DeleteLanguageModelCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -654,7 +654,7 @@ export const deserializeAws_json1_1DeleteLanguageModelCommand = async (output, c
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteLanguageModelCommandError = async (output, context) => {
+const de_DeleteLanguageModelCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -663,13 +663,13 @@ const deserializeAws_json1_1DeleteLanguageModelCommandError = async (output, con
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -680,9 +680,9 @@ const deserializeAws_json1_1DeleteLanguageModelCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1DeleteMedicalTranscriptionJobCommand = async (output, context) => {
+export const de_DeleteMedicalTranscriptionJobCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteMedicalTranscriptionJobCommandError(output, context);
+        return de_DeleteMedicalTranscriptionJobCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -690,7 +690,7 @@ export const deserializeAws_json1_1DeleteMedicalTranscriptionJobCommand = async
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteMedicalTranscriptionJobCommandError = async (output, context) => {
+const de_DeleteMedicalTranscriptionJobCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -699,13 +699,13 @@ const deserializeAws_json1_1DeleteMedicalTranscriptionJobCommandError = async (o
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -716,9 +716,9 @@ const deserializeAws_json1_1DeleteMedicalTranscriptionJobCommandError = async (o
             });
     }
 };
-export const deserializeAws_json1_1DeleteMedicalVocabularyCommand = async (output, context) => {
+export const de_DeleteMedicalVocabularyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteMedicalVocabularyCommandError(output, context);
+        return de_DeleteMedicalVocabularyCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -726,7 +726,7 @@ export const deserializeAws_json1_1DeleteMedicalVocabularyCommand = async (outpu
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteMedicalVocabularyCommandError = async (output, context) => {
+const de_DeleteMedicalVocabularyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -735,16 +735,16 @@ const deserializeAws_json1_1DeleteMedicalVocabularyCommandError = async (output,
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -755,9 +755,9 @@ const deserializeAws_json1_1DeleteMedicalVocabularyCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1DeleteTranscriptionJobCommand = async (output, context) => {
+export const de_DeleteTranscriptionJobCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteTranscriptionJobCommandError(output, context);
+        return de_DeleteTranscriptionJobCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -765,7 +765,7 @@ export const deserializeAws_json1_1DeleteTranscriptionJobCommand = async (output
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteTranscriptionJobCommandError = async (output, context) => {
+const de_DeleteTranscriptionJobCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -774,13 +774,13 @@ const deserializeAws_json1_1DeleteTranscriptionJobCommandError = async (output,
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -791,9 +791,9 @@ const deserializeAws_json1_1DeleteTranscriptionJobCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1DeleteVocabularyCommand = async (output, context) => {
+export const de_DeleteVocabularyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteVocabularyCommandError(output, context);
+        return de_DeleteVocabularyCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -801,7 +801,7 @@ export const deserializeAws_json1_1DeleteVocabularyCommand = async (output, cont
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteVocabularyCommandError = async (output, context) => {
+const de_DeleteVocabularyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -810,16 +810,16 @@ const deserializeAws_json1_1DeleteVocabularyCommandError = async (output, contex
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -830,9 +830,9 @@ const deserializeAws_json1_1DeleteVocabularyCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1DeleteVocabularyFilterCommand = async (output, context) => {
+export const de_DeleteVocabularyFilterCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteVocabularyFilterCommandError(output, context);
+        return de_DeleteVocabularyFilterCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -840,7 +840,7 @@ export const deserializeAws_json1_1DeleteVocabularyFilterCommand = async (output
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteVocabularyFilterCommandError = async (output, context) => {
+const de_DeleteVocabularyFilterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -849,16 +849,16 @@ const deserializeAws_json1_1DeleteVocabularyFilterCommandError = async (output,
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -869,20 +869,20 @@ const deserializeAws_json1_1DeleteVocabularyFilterCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1DescribeLanguageModelCommand = async (output, context) => {
+export const de_DescribeLanguageModelCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeLanguageModelCommandError(output, context);
+        return de_DescribeLanguageModelCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeLanguageModelResponse(data, context);
+    contents = de_DescribeLanguageModelResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeLanguageModelCommandError = async (output, context) => {
+const de_DescribeLanguageModelCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -891,16 +891,16 @@ const deserializeAws_json1_1DescribeLanguageModelCommandError = async (output, c
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -911,20 +911,20 @@ const deserializeAws_json1_1DescribeLanguageModelCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1GetCallAnalyticsCategoryCommand = async (output, context) => {
+export const de_GetCallAnalyticsCategoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetCallAnalyticsCategoryCommandError(output, context);
+        return de_GetCallAnalyticsCategoryCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetCallAnalyticsCategoryResponse(data, context);
+    contents = de_GetCallAnalyticsCategoryResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetCallAnalyticsCategoryCommandError = async (output, context) => {
+const de_GetCallAnalyticsCategoryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -933,16 +933,16 @@ const deserializeAws_json1_1GetCallAnalyticsCategoryCommandError = async (output
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -953,20 +953,20 @@ const deserializeAws_json1_1GetCallAnalyticsCategoryCommandError = async (output
             });
     }
 };
-export const deserializeAws_json1_1GetCallAnalyticsJobCommand = async (output, context) => {
+export const de_GetCallAnalyticsJobCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetCallAnalyticsJobCommandError(output, context);
+        return de_GetCallAnalyticsJobCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetCallAnalyticsJobResponse(data, context);
+    contents = de_GetCallAnalyticsJobResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetCallAnalyticsJobCommandError = async (output, context) => {
+const de_GetCallAnalyticsJobCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -975,16 +975,16 @@ const deserializeAws_json1_1GetCallAnalyticsJobCommandError = async (output, con
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -995,20 +995,20 @@ const deserializeAws_json1_1GetCallAnalyticsJobCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1GetMedicalTranscriptionJobCommand = async (output, context) => {
+export const de_GetMedicalTranscriptionJobCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetMedicalTranscriptionJobCommandError(output, context);
+        return de_GetMedicalTranscriptionJobCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetMedicalTranscriptionJobResponse(data, context);
+    contents = de_GetMedicalTranscriptionJobResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetMedicalTranscriptionJobCommandError = async (output, context) => {
+const de_GetMedicalTranscriptionJobCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1017,16 +1017,16 @@ const deserializeAws_json1_1GetMedicalTranscriptionJobCommandError = async (outp
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1037,20 +1037,20 @@ const deserializeAws_json1_1GetMedicalTranscriptionJobCommandError = async (outp
             });
     }
 };
-export const deserializeAws_json1_1GetMedicalVocabularyCommand = async (output, context) => {
+export const de_GetMedicalVocabularyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetMedicalVocabularyCommandError(output, context);
+        return de_GetMedicalVocabularyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetMedicalVocabularyResponse(data, context);
+    contents = de_GetMedicalVocabularyResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetMedicalVocabularyCommandError = async (output, context) => {
+const de_GetMedicalVocabularyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1059,16 +1059,16 @@ const deserializeAws_json1_1GetMedicalVocabularyCommandError = async (output, co
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1079,20 +1079,20 @@ const deserializeAws_json1_1GetMedicalVocabularyCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_json1_1GetTranscriptionJobCommand = async (output, context) => {
+export const de_GetTranscriptionJobCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetTranscriptionJobCommandError(output, context);
+        return de_GetTranscriptionJobCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetTranscriptionJobResponse(data, context);
+    contents = de_GetTranscriptionJobResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetTranscriptionJobCommandError = async (output, context) => {
+const de_GetTranscriptionJobCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1101,16 +1101,16 @@ const deserializeAws_json1_1GetTranscriptionJobCommandError = async (output, con
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1121,20 +1121,20 @@ const deserializeAws_json1_1GetTranscriptionJobCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1GetVocabularyCommand = async (output, context) => {
+export const de_GetVocabularyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetVocabularyCommandError(output, context);
+        return de_GetVocabularyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetVocabularyResponse(data, context);
+    contents = de_GetVocabularyResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetVocabularyCommandError = async (output, context) => {
+const de_GetVocabularyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1143,16 +1143,16 @@ const deserializeAws_json1_1GetVocabularyCommandError = async (output, context)
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1163,20 +1163,20 @@ const deserializeAws_json1_1GetVocabularyCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1GetVocabularyFilterCommand = async (output, context) => {
+export const de_GetVocabularyFilterCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetVocabularyFilterCommandError(output, context);
+        return de_GetVocabularyFilterCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetVocabularyFilterResponse(data, context);
+    contents = de_GetVocabularyFilterResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetVocabularyFilterCommandError = async (output, context) => {
+const de_GetVocabularyFilterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1185,16 +1185,16 @@ const deserializeAws_json1_1GetVocabularyFilterCommandError = async (output, con
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1205,20 +1205,20 @@ const deserializeAws_json1_1GetVocabularyFilterCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1ListCallAnalyticsCategoriesCommand = async (output, context) => {
+export const de_ListCallAnalyticsCategoriesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListCallAnalyticsCategoriesCommandError(output, context);
+        return de_ListCallAnalyticsCategoriesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListCallAnalyticsCategoriesResponse(data, context);
+    contents = de_ListCallAnalyticsCategoriesResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListCallAnalyticsCategoriesCommandError = async (output, context) => {
+const de_ListCallAnalyticsCategoriesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1227,13 +1227,13 @@ const deserializeAws_json1_1ListCallAnalyticsCategoriesCommandError = async (out
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1244,20 +1244,20 @@ const deserializeAws_json1_1ListCallAnalyticsCategoriesCommandError = async (out
             });
     }
 };
-export const deserializeAws_json1_1ListCallAnalyticsJobsCommand = async (output, context) => {
+export const de_ListCallAnalyticsJobsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListCallAnalyticsJobsCommandError(output, context);
+        return de_ListCallAnalyticsJobsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListCallAnalyticsJobsResponse(data, context);
+    contents = de_ListCallAnalyticsJobsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListCallAnalyticsJobsCommandError = async (output, context) => {
+const de_ListCallAnalyticsJobsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1266,13 +1266,13 @@ const deserializeAws_json1_1ListCallAnalyticsJobsCommandError = async (output, c
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1283,20 +1283,20 @@ const deserializeAws_json1_1ListCallAnalyticsJobsCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1ListLanguageModelsCommand = async (output, context) => {
+export const de_ListLanguageModelsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListLanguageModelsCommandError(output, context);
+        return de_ListLanguageModelsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListLanguageModelsResponse(data, context);
+    contents = de_ListLanguageModelsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListLanguageModelsCommandError = async (output, context) => {
+const de_ListLanguageModelsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1305,13 +1305,13 @@ const deserializeAws_json1_1ListLanguageModelsCommandError = async (output, cont
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1322,20 +1322,20 @@ const deserializeAws_json1_1ListLanguageModelsCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1ListMedicalTranscriptionJobsCommand = async (output, context) => {
+export const de_ListMedicalTranscriptionJobsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListMedicalTranscriptionJobsCommandError(output, context);
+        return de_ListMedicalTranscriptionJobsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListMedicalTranscriptionJobsResponse(data, context);
+    contents = de_ListMedicalTranscriptionJobsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListMedicalTranscriptionJobsCommandError = async (output, context) => {
+const de_ListMedicalTranscriptionJobsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1344,13 +1344,13 @@ const deserializeAws_json1_1ListMedicalTranscriptionJobsCommandError = async (ou
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1361,20 +1361,20 @@ const deserializeAws_json1_1ListMedicalTranscriptionJobsCommandError = async (ou
             });
     }
 };
-export const deserializeAws_json1_1ListMedicalVocabulariesCommand = async (output, context) => {
+export const de_ListMedicalVocabulariesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListMedicalVocabulariesCommandError(output, context);
+        return de_ListMedicalVocabulariesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListMedicalVocabulariesResponse(data, context);
+    contents = de_ListMedicalVocabulariesResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListMedicalVocabulariesCommandError = async (output, context) => {
+const de_ListMedicalVocabulariesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1383,13 +1383,13 @@ const deserializeAws_json1_1ListMedicalVocabulariesCommandError = async (output,
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1400,20 +1400,20 @@ const deserializeAws_json1_1ListMedicalVocabulariesCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1ListTagsForResourceCommand = async (output, context) => {
+export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListTagsForResourceCommandError(output, context);
+        return de_ListTagsForResourceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListTagsForResourceResponse(data, context);
+    contents = de_ListTagsForResourceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, context) => {
+const de_ListTagsForResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1422,16 +1422,16 @@ const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, con
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1442,20 +1442,20 @@ const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1ListTranscriptionJobsCommand = async (output, context) => {
+export const de_ListTranscriptionJobsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListTranscriptionJobsCommandError(output, context);
+        return de_ListTranscriptionJobsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListTranscriptionJobsResponse(data, context);
+    contents = de_ListTranscriptionJobsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListTranscriptionJobsCommandError = async (output, context) => {
+const de_ListTranscriptionJobsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1464,13 +1464,13 @@ const deserializeAws_json1_1ListTranscriptionJobsCommandError = async (output, c
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1481,20 +1481,20 @@ const deserializeAws_json1_1ListTranscriptionJobsCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1ListVocabulariesCommand = async (output, context) => {
+export const de_ListVocabulariesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListVocabulariesCommandError(output, context);
+        return de_ListVocabulariesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListVocabulariesResponse(data, context);
+    contents = de_ListVocabulariesResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListVocabulariesCommandError = async (output, context) => {
+const de_ListVocabulariesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1503,13 +1503,13 @@ const deserializeAws_json1_1ListVocabulariesCommandError = async (output, contex
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1520,20 +1520,20 @@ const deserializeAws_json1_1ListVocabulariesCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1ListVocabularyFiltersCommand = async (output, context) => {
+export const de_ListVocabularyFiltersCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListVocabularyFiltersCommandError(output, context);
+        return de_ListVocabularyFiltersCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListVocabularyFiltersResponse(data, context);
+    contents = de_ListVocabularyFiltersResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListVocabularyFiltersCommandError = async (output, context) => {
+const de_ListVocabularyFiltersCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1542,13 +1542,13 @@ const deserializeAws_json1_1ListVocabularyFiltersCommandError = async (output, c
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1559,20 +1559,20 @@ const deserializeAws_json1_1ListVocabularyFiltersCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1StartCallAnalyticsJobCommand = async (output, context) => {
+export const de_StartCallAnalyticsJobCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1StartCallAnalyticsJobCommandError(output, context);
+        return de_StartCallAnalyticsJobCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1StartCallAnalyticsJobResponse(data, context);
+    contents = de_StartCallAnalyticsJobResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1StartCallAnalyticsJobCommandError = async (output, context) => {
+const de_StartCallAnalyticsJobCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1581,16 +1581,16 @@ const deserializeAws_json1_1StartCallAnalyticsJobCommandError = async (output, c
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribe#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1601,20 +1601,20 @@ const deserializeAws_json1_1StartCallAnalyticsJobCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1StartMedicalTranscriptionJobCommand = async (output, context) => {
+export const de_StartMedicalTranscriptionJobCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1StartMedicalTranscriptionJobCommandError(output, context);
+        return de_StartMedicalTranscriptionJobCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1StartMedicalTranscriptionJobResponse(data, context);
+    contents = de_StartMedicalTranscriptionJobResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1StartMedicalTranscriptionJobCommandError = async (output, context) => {
+const de_StartMedicalTranscriptionJobCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1623,16 +1623,16 @@ const deserializeAws_json1_1StartMedicalTranscriptionJobCommandError = async (ou
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribe#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1643,20 +1643,20 @@ const deserializeAws_json1_1StartMedicalTranscriptionJobCommandError = async (ou
             });
     }
 };
-export const deserializeAws_json1_1StartTranscriptionJobCommand = async (output, context) => {
+export const de_StartTranscriptionJobCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1StartTranscriptionJobCommandError(output, context);
+        return de_StartTranscriptionJobCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1StartTranscriptionJobResponse(data, context);
+    contents = de_StartTranscriptionJobResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1StartTranscriptionJobCommandError = async (output, context) => {
+const de_StartTranscriptionJobCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1665,16 +1665,16 @@ const deserializeAws_json1_1StartTranscriptionJobCommandError = async (output, c
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribe#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1685,20 +1685,20 @@ const deserializeAws_json1_1StartTranscriptionJobCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1TagResourceCommand = async (output, context) => {
+export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1TagResourceCommandError(output, context);
+        return de_TagResourceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1TagResourceResponse(data, context);
+    contents = de_TagResourceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1TagResourceCommandError = async (output, context) => {
+const de_TagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1707,19 +1707,19 @@ const deserializeAws_json1_1TagResourceCommandError = async (output, context) =>
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribe#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1730,20 +1730,20 @@ const deserializeAws_json1_1TagResourceCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_json1_1UntagResourceCommand = async (output, context) => {
+export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UntagResourceCommandError(output, context);
+        return de_UntagResourceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UntagResourceResponse(data, context);
+    contents = de_UntagResourceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UntagResourceCommandError = async (output, context) => {
+const de_UntagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1752,19 +1752,19 @@ const deserializeAws_json1_1UntagResourceCommandError = async (output, context)
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribe#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1775,20 +1775,20 @@ const deserializeAws_json1_1UntagResourceCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1UpdateCallAnalyticsCategoryCommand = async (output, context) => {
+export const de_UpdateCallAnalyticsCategoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UpdateCallAnalyticsCategoryCommandError(output, context);
+        return de_UpdateCallAnalyticsCategoryCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UpdateCallAnalyticsCategoryResponse(data, context);
+    contents = de_UpdateCallAnalyticsCategoryResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UpdateCallAnalyticsCategoryCommandError = async (output, context) => {
+const de_UpdateCallAnalyticsCategoryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1797,19 +1797,19 @@ const deserializeAws_json1_1UpdateCallAnalyticsCategoryCommandError = async (out
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribe#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1820,20 +1820,20 @@ const deserializeAws_json1_1UpdateCallAnalyticsCategoryCommandError = async (out
             });
     }
 };
-export const deserializeAws_json1_1UpdateMedicalVocabularyCommand = async (output, context) => {
+export const de_UpdateMedicalVocabularyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UpdateMedicalVocabularyCommandError(output, context);
+        return de_UpdateMedicalVocabularyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UpdateMedicalVocabularyResponse(data, context);
+    contents = de_UpdateMedicalVocabularyResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UpdateMedicalVocabularyCommandError = async (output, context) => {
+const de_UpdateMedicalVocabularyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1842,19 +1842,19 @@ const deserializeAws_json1_1UpdateMedicalVocabularyCommandError = async (output,
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribe#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1865,20 +1865,20 @@ const deserializeAws_json1_1UpdateMedicalVocabularyCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1UpdateVocabularyCommand = async (output, context) => {
+export const de_UpdateVocabularyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UpdateVocabularyCommandError(output, context);
+        return de_UpdateVocabularyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UpdateVocabularyResponse(data, context);
+    contents = de_UpdateVocabularyResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UpdateVocabularyCommandError = async (output, context) => {
+const de_UpdateVocabularyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1887,19 +1887,19 @@ const deserializeAws_json1_1UpdateVocabularyCommandError = async (output, contex
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.transcribe#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1910,20 +1910,20 @@ const deserializeAws_json1_1UpdateVocabularyCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1UpdateVocabularyFilterCommand = async (output, context) => {
+export const de_UpdateVocabularyFilterCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UpdateVocabularyFilterCommandError(output, context);
+        return de_UpdateVocabularyFilterCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UpdateVocabularyFilterResponse(data, context);
+    contents = de_UpdateVocabularyFilterResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UpdateVocabularyFilterCommandError = async (output, context) => {
+const de_UpdateVocabularyFilterCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1932,16 +1932,16 @@ const deserializeAws_json1_1UpdateVocabularyFilterCommandError = async (output,
     switch (errorCode) {
         case "BadRequestException":
         case "com.amazonaws.transcribe#BadRequestException":
-            throw await deserializeAws_json1_1BadRequestExceptionResponse(parsedOutput, context);
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
         case "InternalFailureException":
         case "com.amazonaws.transcribe#InternalFailureException":
-            throw await deserializeAws_json1_1InternalFailureExceptionResponse(parsedOutput, context);
+            throw await de_InternalFailureExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.transcribe#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.transcribe#NotFoundException":
-            throw await deserializeAws_json1_1NotFoundExceptionResponse(parsedOutput, context);
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1952,52 +1952,52 @@ const deserializeAws_json1_1UpdateVocabularyFilterCommandError = async (output,
             });
     }
 };
-const deserializeAws_json1_1BadRequestExceptionResponse = async (parsedOutput, context) => {
+const de_BadRequestExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1BadRequestException(body, context);
+    const deserialized = de_BadRequestException(body, context);
     const exception = new BadRequestException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ConflictExceptionResponse = async (parsedOutput, context) => {
+const de_ConflictExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ConflictException(body, context);
+    const deserialized = de_ConflictException(body, context);
     const exception = new ConflictException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InternalFailureExceptionResponse = async (parsedOutput, context) => {
+const de_InternalFailureExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InternalFailureException(body, context);
+    const deserialized = de_InternalFailureException(body, context);
     const exception = new InternalFailureException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1LimitExceededExceptionResponse = async (parsedOutput, context) => {
+const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1LimitExceededException(body, context);
+    const deserialized = de_LimitExceededException(body, context);
     const exception = new LimitExceededException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1NotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_NotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1NotFoundException(body, context);
+    const deserialized = de_NotFoundException(body, context);
     const exception = new NotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const serializeAws_json1_1AbsoluteTimeRange = (input, context) => {
+const se_AbsoluteTimeRange = (input, context) => {
     return {
         ...(input.EndTime != null && { EndTime: input.EndTime }),
         ...(input.First != null && { First: input.First }),
@@ -2005,202 +2005,194 @@ const serializeAws_json1_1AbsoluteTimeRange = (input, context) => {
         ...(input.StartTime != null && { StartTime: input.StartTime }),
     };
 };
-const serializeAws_json1_1CallAnalyticsJobSettings = (input, context) => {
+const se_CallAnalyticsJobSettings = (input, context) => {
     return {
-        ...(input.ContentRedaction != null && {
-            ContentRedaction: serializeAws_json1_1ContentRedaction(input.ContentRedaction, context),
-        }),
+        ...(input.ContentRedaction != null && { ContentRedaction: se_ContentRedaction(input.ContentRedaction, context) }),
         ...(input.LanguageIdSettings != null && {
-            LanguageIdSettings: serializeAws_json1_1LanguageIdSettingsMap(input.LanguageIdSettings, context),
+            LanguageIdSettings: se_LanguageIdSettingsMap(input.LanguageIdSettings, context),
         }),
         ...(input.LanguageModelName != null && { LanguageModelName: input.LanguageModelName }),
-        ...(input.LanguageOptions != null && {
-            LanguageOptions: serializeAws_json1_1LanguageOptions(input.LanguageOptions, context),
-        }),
+        ...(input.LanguageOptions != null && { LanguageOptions: se_LanguageOptions(input.LanguageOptions, context) }),
         ...(input.VocabularyFilterMethod != null && { VocabularyFilterMethod: input.VocabularyFilterMethod }),
         ...(input.VocabularyFilterName != null && { VocabularyFilterName: input.VocabularyFilterName }),
         ...(input.VocabularyName != null && { VocabularyName: input.VocabularyName }),
     };
 };
-const serializeAws_json1_1ChannelDefinition = (input, context) => {
+const se_ChannelDefinition = (input, context) => {
     return {
         ...(input.ChannelId != null && { ChannelId: input.ChannelId }),
         ...(input.ParticipantRole != null && { ParticipantRole: input.ParticipantRole }),
     };
 };
-const serializeAws_json1_1ChannelDefinitions = (input, context) => {
+const se_ChannelDefinitions = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1ChannelDefinition(entry, context);
+        return se_ChannelDefinition(entry, context);
     });
 };
-const serializeAws_json1_1ContentRedaction = (input, context) => {
+const se_ContentRedaction = (input, context) => {
     return {
-        ...(input.PiiEntityTypes != null && {
-            PiiEntityTypes: serializeAws_json1_1PiiEntityTypes(input.PiiEntityTypes, context),
-        }),
+        ...(input.PiiEntityTypes != null && { PiiEntityTypes: se_PiiEntityTypes(input.PiiEntityTypes, context) }),
         ...(input.RedactionOutput != null && { RedactionOutput: input.RedactionOutput }),
         ...(input.RedactionType != null && { RedactionType: input.RedactionType }),
     };
 };
-const serializeAws_json1_1CreateCallAnalyticsCategoryRequest = (input, context) => {
+const se_CreateCallAnalyticsCategoryRequest = (input, context) => {
     return {
         ...(input.CategoryName != null && { CategoryName: input.CategoryName }),
         ...(input.InputType != null && { InputType: input.InputType }),
-        ...(input.Rules != null && { Rules: serializeAws_json1_1RuleList(input.Rules, context) }),
+        ...(input.Rules != null && { Rules: se_RuleList(input.Rules, context) }),
     };
 };
-const serializeAws_json1_1CreateLanguageModelRequest = (input, context) => {
+const se_CreateLanguageModelRequest = (input, context) => {
     return {
         ...(input.BaseModelName != null && { BaseModelName: input.BaseModelName }),
-        ...(input.InputDataConfig != null && {
-            InputDataConfig: serializeAws_json1_1InputDataConfig(input.InputDataConfig, context),
-        }),
+        ...(input.InputDataConfig != null && { InputDataConfig: se_InputDataConfig(input.InputDataConfig, context) }),
         ...(input.LanguageCode != null && { LanguageCode: input.LanguageCode }),
         ...(input.ModelName != null && { ModelName: input.ModelName }),
-        ...(input.Tags != null && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
+        ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
     };
 };
-const serializeAws_json1_1CreateMedicalVocabularyRequest = (input, context) => {
+const se_CreateMedicalVocabularyRequest = (input, context) => {
     return {
         ...(input.LanguageCode != null && { LanguageCode: input.LanguageCode }),
-        ...(input.Tags != null && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
+        ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
         ...(input.VocabularyFileUri != null && { VocabularyFileUri: input.VocabularyFileUri }),
         ...(input.VocabularyName != null && { VocabularyName: input.VocabularyName }),
     };
 };
-const serializeAws_json1_1CreateVocabularyFilterRequest = (input, context) => {
+const se_CreateVocabularyFilterRequest = (input, context) => {
     return {
         ...(input.DataAccessRoleArn != null && { DataAccessRoleArn: input.DataAccessRoleArn }),
         ...(input.LanguageCode != null && { LanguageCode: input.LanguageCode }),
-        ...(input.Tags != null && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
+        ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
         ...(input.VocabularyFilterFileUri != null && { VocabularyFilterFileUri: input.VocabularyFilterFileUri }),
         ...(input.VocabularyFilterName != null && { VocabularyFilterName: input.VocabularyFilterName }),
-        ...(input.Words != null && { Words: serializeAws_json1_1Words(input.Words, context) }),
+        ...(input.Words != null && { Words: se_Words(input.Words, context) }),
     };
 };
-const serializeAws_json1_1CreateVocabularyRequest = (input, context) => {
+const se_CreateVocabularyRequest = (input, context) => {
     return {
         ...(input.DataAccessRoleArn != null && { DataAccessRoleArn: input.DataAccessRoleArn }),
         ...(input.LanguageCode != null && { LanguageCode: input.LanguageCode }),
-        ...(input.Phrases != null && { Phrases: serializeAws_json1_1Phrases(input.Phrases, context) }),
-        ...(input.Tags != null && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
+        ...(input.Phrases != null && { Phrases: se_Phrases(input.Phrases, context) }),
+        ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
         ...(input.VocabularyFileUri != null && { VocabularyFileUri: input.VocabularyFileUri }),
         ...(input.VocabularyName != null && { VocabularyName: input.VocabularyName }),
     };
 };
-const serializeAws_json1_1DeleteCallAnalyticsCategoryRequest = (input, context) => {
+const se_DeleteCallAnalyticsCategoryRequest = (input, context) => {
     return {
         ...(input.CategoryName != null && { CategoryName: input.CategoryName }),
     };
 };
-const serializeAws_json1_1DeleteCallAnalyticsJobRequest = (input, context) => {
+const se_DeleteCallAnalyticsJobRequest = (input, context) => {
     return {
         ...(input.CallAnalyticsJobName != null && { CallAnalyticsJobName: input.CallAnalyticsJobName }),
     };
 };
-const serializeAws_json1_1DeleteLanguageModelRequest = (input, context) => {
+const se_DeleteLanguageModelRequest = (input, context) => {
     return {
         ...(input.ModelName != null && { ModelName: input.ModelName }),
     };
 };
-const serializeAws_json1_1DeleteMedicalTranscriptionJobRequest = (input, context) => {
+const se_DeleteMedicalTranscriptionJobRequest = (input, context) => {
     return {
         ...(input.MedicalTranscriptionJobName != null && {
             MedicalTranscriptionJobName: input.MedicalTranscriptionJobName,
         }),
     };
 };
-const serializeAws_json1_1DeleteMedicalVocabularyRequest = (input, context) => {
+const se_DeleteMedicalVocabularyRequest = (input, context) => {
     return {
         ...(input.VocabularyName != null && { VocabularyName: input.VocabularyName }),
     };
 };
-const serializeAws_json1_1DeleteTranscriptionJobRequest = (input, context) => {
+const se_DeleteTranscriptionJobRequest = (input, context) => {
     return {
         ...(input.TranscriptionJobName != null && { TranscriptionJobName: input.TranscriptionJobName }),
     };
 };
-const serializeAws_json1_1DeleteVocabularyFilterRequest = (input, context) => {
+const se_DeleteVocabularyFilterRequest = (input, context) => {
     return {
         ...(input.VocabularyFilterName != null && { VocabularyFilterName: input.VocabularyFilterName }),
     };
 };
-const serializeAws_json1_1DeleteVocabularyRequest = (input, context) => {
+const se_DeleteVocabularyRequest = (input, context) => {
     return {
         ...(input.VocabularyName != null && { VocabularyName: input.VocabularyName }),
     };
 };
-const serializeAws_json1_1DescribeLanguageModelRequest = (input, context) => {
+const se_DescribeLanguageModelRequest = (input, context) => {
     return {
         ...(input.ModelName != null && { ModelName: input.ModelName }),
     };
 };
-const serializeAws_json1_1GetCallAnalyticsCategoryRequest = (input, context) => {
+const se_GetCallAnalyticsCategoryRequest = (input, context) => {
     return {
         ...(input.CategoryName != null && { CategoryName: input.CategoryName }),
     };
 };
-const serializeAws_json1_1GetCallAnalyticsJobRequest = (input, context) => {
+const se_GetCallAnalyticsJobRequest = (input, context) => {
     return {
         ...(input.CallAnalyticsJobName != null && { CallAnalyticsJobName: input.CallAnalyticsJobName }),
     };
 };
-const serializeAws_json1_1GetMedicalTranscriptionJobRequest = (input, context) => {
+const se_GetMedicalTranscriptionJobRequest = (input, context) => {
     return {
         ...(input.MedicalTranscriptionJobName != null && {
             MedicalTranscriptionJobName: input.MedicalTranscriptionJobName,
         }),
     };
 };
-const serializeAws_json1_1GetMedicalVocabularyRequest = (input, context) => {
+const se_GetMedicalVocabularyRequest = (input, context) => {
     return {
         ...(input.VocabularyName != null && { VocabularyName: input.VocabularyName }),
     };
 };
-const serializeAws_json1_1GetTranscriptionJobRequest = (input, context) => {
+const se_GetTranscriptionJobRequest = (input, context) => {
     return {
         ...(input.TranscriptionJobName != null && { TranscriptionJobName: input.TranscriptionJobName }),
     };
 };
-const serializeAws_json1_1GetVocabularyFilterRequest = (input, context) => {
+const se_GetVocabularyFilterRequest = (input, context) => {
     return {
         ...(input.VocabularyFilterName != null && { VocabularyFilterName: input.VocabularyFilterName }),
     };
 };
-const serializeAws_json1_1GetVocabularyRequest = (input, context) => {
+const se_GetVocabularyRequest = (input, context) => {
     return {
         ...(input.VocabularyName != null && { VocabularyName: input.VocabularyName }),
     };
 };
-const serializeAws_json1_1InputDataConfig = (input, context) => {
+const se_InputDataConfig = (input, context) => {
     return {
         ...(input.DataAccessRoleArn != null && { DataAccessRoleArn: input.DataAccessRoleArn }),
         ...(input.S3Uri != null && { S3Uri: input.S3Uri }),
         ...(input.TuningDataS3Uri != null && { TuningDataS3Uri: input.TuningDataS3Uri }),
     };
 };
-const serializeAws_json1_1InterruptionFilter = (input, context) => {
+const se_InterruptionFilter = (input, context) => {
     return {
         ...(input.AbsoluteTimeRange != null && {
-            AbsoluteTimeRange: serializeAws_json1_1AbsoluteTimeRange(input.AbsoluteTimeRange, context),
+            AbsoluteTimeRange: se_AbsoluteTimeRange(input.AbsoluteTimeRange, context),
         }),
         ...(input.Negate != null && { Negate: input.Negate }),
         ...(input.ParticipantRole != null && { ParticipantRole: input.ParticipantRole }),
         ...(input.RelativeTimeRange != null && {
-            RelativeTimeRange: serializeAws_json1_1RelativeTimeRange(input.RelativeTimeRange, context),
+            RelativeTimeRange: se_RelativeTimeRange(input.RelativeTimeRange, context),
         }),
         ...(input.Threshold != null && { Threshold: input.Threshold }),
     };
 };
-const serializeAws_json1_1JobExecutionSettings = (input, context) => {
+const se_JobExecutionSettings = (input, context) => {
     return {
         ...(input.AllowDeferredExecution != null && { AllowDeferredExecution: input.AllowDeferredExecution }),
         ...(input.DataAccessRoleArn != null && { DataAccessRoleArn: input.DataAccessRoleArn }),
     };
 };
-const serializeAws_json1_1KMSEncryptionContextMap = (input, context) => {
+const se_KMSEncryptionContextMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -2209,36 +2201,36 @@ const serializeAws_json1_1KMSEncryptionContextMap = (input, context) => {
         return acc;
     }, {});
 };
-const serializeAws_json1_1LanguageIdSettings = (input, context) => {
+const se_LanguageIdSettings = (input, context) => {
     return {
         ...(input.LanguageModelName != null && { LanguageModelName: input.LanguageModelName }),
         ...(input.VocabularyFilterName != null && { VocabularyFilterName: input.VocabularyFilterName }),
         ...(input.VocabularyName != null && { VocabularyName: input.VocabularyName }),
     };
 };
-const serializeAws_json1_1LanguageIdSettingsMap = (input, context) => {
+const se_LanguageIdSettingsMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = serializeAws_json1_1LanguageIdSettings(value, context);
+        acc[key] = se_LanguageIdSettings(value, context);
         return acc;
     }, {});
 };
-const serializeAws_json1_1LanguageOptions = (input, context) => {
+const se_LanguageOptions = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1ListCallAnalyticsCategoriesRequest = (input, context) => {
+const se_ListCallAnalyticsCategoriesRequest = (input, context) => {
     return {
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
         ...(input.NextToken != null && { NextToken: input.NextToken }),
     };
 };
-const serializeAws_json1_1ListCallAnalyticsJobsRequest = (input, context) => {
+const se_ListCallAnalyticsJobsRequest = (input, context) => {
     return {
         ...(input.JobNameContains != null && { JobNameContains: input.JobNameContains }),
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
@@ -2246,7 +2238,7 @@ const serializeAws_json1_1ListCallAnalyticsJobsRequest = (input, context) => {
         ...(input.Status != null && { Status: input.Status }),
     };
 };
-const serializeAws_json1_1ListLanguageModelsRequest = (input, context) => {
+const se_ListLanguageModelsRequest = (input, context) => {
     return {
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
         ...(input.NameContains != null && { NameContains: input.NameContains }),
@@ -2254,7 +2246,7 @@ const serializeAws_json1_1ListLanguageModelsRequest = (input, context) => {
         ...(input.StatusEquals != null && { StatusEquals: input.StatusEquals }),
     };
 };
-const serializeAws_json1_1ListMedicalTranscriptionJobsRequest = (input, context) => {
+const se_ListMedicalTranscriptionJobsRequest = (input, context) => {
     return {
         ...(input.JobNameContains != null && { JobNameContains: input.JobNameContains }),
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
@@ -2262,7 +2254,7 @@ const serializeAws_json1_1ListMedicalTranscriptionJobsRequest = (input, context)
         ...(input.Status != null && { Status: input.Status }),
     };
 };
-const serializeAws_json1_1ListMedicalVocabulariesRequest = (input, context) => {
+const se_ListMedicalVocabulariesRequest = (input, context) => {
     return {
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
         ...(input.NameContains != null && { NameContains: input.NameContains }),
@@ -2270,12 +2262,12 @@ const serializeAws_json1_1ListMedicalVocabulariesRequest = (input, context) => {
         ...(input.StateEquals != null && { StateEquals: input.StateEquals }),
     };
 };
-const serializeAws_json1_1ListTagsForResourceRequest = (input, context) => {
+const se_ListTagsForResourceRequest = (input, context) => {
     return {
         ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
     };
 };
-const serializeAws_json1_1ListTranscriptionJobsRequest = (input, context) => {
+const se_ListTranscriptionJobsRequest = (input, context) => {
     return {
         ...(input.JobNameContains != null && { JobNameContains: input.JobNameContains }),
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
@@ -2283,7 +2275,7 @@ const serializeAws_json1_1ListTranscriptionJobsRequest = (input, context) => {
         ...(input.Status != null && { Status: input.Status }),
     };
 };
-const serializeAws_json1_1ListVocabulariesRequest = (input, context) => {
+const se_ListVocabulariesRequest = (input, context) => {
     return {
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
         ...(input.NameContains != null && { NameContains: input.NameContains }),
@@ -2291,20 +2283,20 @@ const serializeAws_json1_1ListVocabulariesRequest = (input, context) => {
         ...(input.StateEquals != null && { StateEquals: input.StateEquals }),
     };
 };
-const serializeAws_json1_1ListVocabularyFiltersRequest = (input, context) => {
+const se_ListVocabularyFiltersRequest = (input, context) => {
     return {
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
         ...(input.NameContains != null && { NameContains: input.NameContains }),
         ...(input.NextToken != null && { NextToken: input.NextToken }),
     };
 };
-const serializeAws_json1_1Media = (input, context) => {
+const se_Media = (input, context) => {
     return {
         ...(input.MediaFileUri != null && { MediaFileUri: input.MediaFileUri }),
         ...(input.RedactedMediaFileUri != null && { RedactedMediaFileUri: input.RedactedMediaFileUri }),
     };
 };
-const serializeAws_json1_1MedicalTranscriptionSetting = (input, context) => {
+const se_MedicalTranscriptionSetting = (input, context) => {
     return {
         ...(input.ChannelIdentification != null && { ChannelIdentification: input.ChannelIdentification }),
         ...(input.MaxAlternatives != null && { MaxAlternatives: input.MaxAlternatives }),
@@ -2314,38 +2306,38 @@ const serializeAws_json1_1MedicalTranscriptionSetting = (input, context) => {
         ...(input.VocabularyName != null && { VocabularyName: input.VocabularyName }),
     };
 };
-const serializeAws_json1_1ModelSettings = (input, context) => {
+const se_ModelSettings = (input, context) => {
     return {
         ...(input.LanguageModelName != null && { LanguageModelName: input.LanguageModelName }),
     };
 };
-const serializeAws_json1_1NonTalkTimeFilter = (input, context) => {
+const se_NonTalkTimeFilter = (input, context) => {
     return {
         ...(input.AbsoluteTimeRange != null && {
-            AbsoluteTimeRange: serializeAws_json1_1AbsoluteTimeRange(input.AbsoluteTimeRange, context),
+            AbsoluteTimeRange: se_AbsoluteTimeRange(input.AbsoluteTimeRange, context),
         }),
         ...(input.Negate != null && { Negate: input.Negate }),
         ...(input.RelativeTimeRange != null && {
-            RelativeTimeRange: serializeAws_json1_1RelativeTimeRange(input.RelativeTimeRange, context),
+            RelativeTimeRange: se_RelativeTimeRange(input.RelativeTimeRange, context),
         }),
         ...(input.Threshold != null && { Threshold: input.Threshold }),
     };
 };
-const serializeAws_json1_1Phrases = (input, context) => {
+const se_Phrases = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1PiiEntityTypes = (input, context) => {
+const se_PiiEntityTypes = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1RelativeTimeRange = (input, context) => {
+const se_RelativeTimeRange = (input, context) => {
     return {
         ...(input.EndPercentage != null && { EndPercentage: input.EndPercentage }),
         ...(input.First != null && { First: input.First }),
@@ -2353,43 +2345,43 @@ const serializeAws_json1_1RelativeTimeRange = (input, context) => {
         ...(input.StartPercentage != null && { StartPercentage: input.StartPercentage }),
     };
 };
-const serializeAws_json1_1Rule = (input, context) => {
+const se_Rule = (input, context) => {
     return Rule.visit(input, {
-        InterruptionFilter: (value) => ({ InterruptionFilter: serializeAws_json1_1InterruptionFilter(value, context) }),
-        NonTalkTimeFilter: (value) => ({ NonTalkTimeFilter: serializeAws_json1_1NonTalkTimeFilter(value, context) }),
-        SentimentFilter: (value) => ({ SentimentFilter: serializeAws_json1_1SentimentFilter(value, context) }),
-        TranscriptFilter: (value) => ({ TranscriptFilter: serializeAws_json1_1TranscriptFilter(value, context) }),
+        InterruptionFilter: (value) => ({ InterruptionFilter: se_InterruptionFilter(value, context) }),
+        NonTalkTimeFilter: (value) => ({ NonTalkTimeFilter: se_NonTalkTimeFilter(value, context) }),
+        SentimentFilter: (value) => ({ SentimentFilter: se_SentimentFilter(value, context) }),
+        TranscriptFilter: (value) => ({ TranscriptFilter: se_TranscriptFilter(value, context) }),
         _: (name, value) => ({ name: value }),
     });
 };
-const serializeAws_json1_1RuleList = (input, context) => {
+const se_RuleList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1Rule(entry, context);
+        return se_Rule(entry, context);
     });
 };
-const serializeAws_json1_1SentimentFilter = (input, context) => {
+const se_SentimentFilter = (input, context) => {
     return {
         ...(input.AbsoluteTimeRange != null && {
-            AbsoluteTimeRange: serializeAws_json1_1AbsoluteTimeRange(input.AbsoluteTimeRange, context),
+            AbsoluteTimeRange: se_AbsoluteTimeRange(input.AbsoluteTimeRange, context),
         }),
         ...(input.Negate != null && { Negate: input.Negate }),
         ...(input.ParticipantRole != null && { ParticipantRole: input.ParticipantRole }),
         ...(input.RelativeTimeRange != null && {
-            RelativeTimeRange: serializeAws_json1_1RelativeTimeRange(input.RelativeTimeRange, context),
+            RelativeTimeRange: se_RelativeTimeRange(input.RelativeTimeRange, context),
         }),
-        ...(input.Sentiments != null && { Sentiments: serializeAws_json1_1SentimentValueList(input.Sentiments, context) }),
+        ...(input.Sentiments != null && { Sentiments: se_SentimentValueList(input.Sentiments, context) }),
     };
 };
-const serializeAws_json1_1SentimentValueList = (input, context) => {
+const se_SentimentValueList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1Settings = (input, context) => {
+const se_Settings = (input, context) => {
     return {
         ...(input.ChannelIdentification != null && { ChannelIdentification: input.ChannelIdentification }),
         ...(input.MaxAlternatives != null && { MaxAlternatives: input.MaxAlternatives }),
@@ -2401,27 +2393,27 @@ const serializeAws_json1_1Settings = (input, context) => {
         ...(input.VocabularyName != null && { VocabularyName: input.VocabularyName }),
     };
 };
-const serializeAws_json1_1StartCallAnalyticsJobRequest = (input, context) => {
+const se_StartCallAnalyticsJobRequest = (input, context) => {
     return {
         ...(input.CallAnalyticsJobName != null && { CallAnalyticsJobName: input.CallAnalyticsJobName }),
         ...(input.ChannelDefinitions != null && {
-            ChannelDefinitions: serializeAws_json1_1ChannelDefinitions(input.ChannelDefinitions, context),
+            ChannelDefinitions: se_ChannelDefinitions(input.ChannelDefinitions, context),
         }),
         ...(input.DataAccessRoleArn != null && { DataAccessRoleArn: input.DataAccessRoleArn }),
-        ...(input.Media != null && { Media: serializeAws_json1_1Media(input.Media, context) }),
+        ...(input.Media != null && { Media: se_Media(input.Media, context) }),
         ...(input.OutputEncryptionKMSKeyId != null && { OutputEncryptionKMSKeyId: input.OutputEncryptionKMSKeyId }),
         ...(input.OutputLocation != null && { OutputLocation: input.OutputLocation }),
-        ...(input.Settings != null && { Settings: serializeAws_json1_1CallAnalyticsJobSettings(input.Settings, context) }),
+        ...(input.Settings != null && { Settings: se_CallAnalyticsJobSettings(input.Settings, context) }),
     };
 };
-const serializeAws_json1_1StartMedicalTranscriptionJobRequest = (input, context) => {
+const se_StartMedicalTranscriptionJobRequest = (input, context) => {
     return {
         ...(input.ContentIdentificationType != null && { ContentIdentificationType: input.ContentIdentificationType }),
         ...(input.KMSEncryptionContext != null && {
-            KMSEncryptionContext: serializeAws_json1_1KMSEncryptionContextMap(input.KMSEncryptionContext, context),
+            KMSEncryptionContext: se_KMSEncryptionContextMap(input.KMSEncryptionContext, context),
         }),
         ...(input.LanguageCode != null && { LanguageCode: input.LanguageCode }),
-        ...(input.Media != null && { Media: serializeAws_json1_1Media(input.Media, context) }),
+        ...(input.Media != null && { Media: se_Media(input.Media, context) }),
         ...(input.MediaFormat != null && { MediaFormat: input.MediaFormat }),
         ...(input.MediaSampleRateHertz != null && { MediaSampleRateHertz: input.MediaSampleRateHertz }),
         ...(input.MedicalTranscriptionJobName != null && {
@@ -2430,154 +2422,146 @@ const serializeAws_json1_1StartMedicalTranscriptionJobRequest = (input, context)
         ...(input.OutputBucketName != null && { OutputBucketName: input.OutputBucketName }),
         ...(input.OutputEncryptionKMSKeyId != null && { OutputEncryptionKMSKeyId: input.OutputEncryptionKMSKeyId }),
         ...(input.OutputKey != null && { OutputKey: input.OutputKey }),
-        ...(input.Settings != null && {
-            Settings: serializeAws_json1_1MedicalTranscriptionSetting(input.Settings, context),
-        }),
+        ...(input.Settings != null && { Settings: se_MedicalTranscriptionSetting(input.Settings, context) }),
         ...(input.Specialty != null && { Specialty: input.Specialty }),
-        ...(input.Tags != null && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
+        ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
         ...(input.Type != null && { Type: input.Type }),
     };
 };
-const serializeAws_json1_1StartTranscriptionJobRequest = (input, context) => {
+const se_StartTranscriptionJobRequest = (input, context) => {
     return {
-        ...(input.ContentRedaction != null && {
-            ContentRedaction: serializeAws_json1_1ContentRedaction(input.ContentRedaction, context),
-        }),
+        ...(input.ContentRedaction != null && { ContentRedaction: se_ContentRedaction(input.ContentRedaction, context) }),
         ...(input.IdentifyLanguage != null && { IdentifyLanguage: input.IdentifyLanguage }),
         ...(input.IdentifyMultipleLanguages != null && { IdentifyMultipleLanguages: input.IdentifyMultipleLanguages }),
         ...(input.JobExecutionSettings != null && {
-            JobExecutionSettings: serializeAws_json1_1JobExecutionSettings(input.JobExecutionSettings, context),
+            JobExecutionSettings: se_JobExecutionSettings(input.JobExecutionSettings, context),
         }),
         ...(input.KMSEncryptionContext != null && {
-            KMSEncryptionContext: serializeAws_json1_1KMSEncryptionContextMap(input.KMSEncryptionContext, context),
+            KMSEncryptionContext: se_KMSEncryptionContextMap(input.KMSEncryptionContext, context),
         }),
         ...(input.LanguageCode != null && { LanguageCode: input.LanguageCode }),
         ...(input.LanguageIdSettings != null && {
-            LanguageIdSettings: serializeAws_json1_1LanguageIdSettingsMap(input.LanguageIdSettings, context),
-        }),
-        ...(input.LanguageOptions != null && {
-            LanguageOptions: serializeAws_json1_1LanguageOptions(input.LanguageOptions, context),
+            LanguageIdSettings: se_LanguageIdSettingsMap(input.LanguageIdSettings, context),
         }),
-        ...(input.Media != null && { Media: serializeAws_json1_1Media(input.Media, context) }),
+        ...(input.LanguageOptions != null && { LanguageOptions: se_LanguageOptions(input.LanguageOptions, context) }),
+        ...(input.Media != null && { Media: se_Media(input.Media, context) }),
         ...(input.MediaFormat != null && { MediaFormat: input.MediaFormat }),
         ...(input.MediaSampleRateHertz != null && { MediaSampleRateHertz: input.MediaSampleRateHertz }),
-        ...(input.ModelSettings != null && {
-            ModelSettings: serializeAws_json1_1ModelSettings(input.ModelSettings, context),
-        }),
+        ...(input.ModelSettings != null && { ModelSettings: se_ModelSettings(input.ModelSettings, context) }),
         ...(input.OutputBucketName != null && { OutputBucketName: input.OutputBucketName }),
         ...(input.OutputEncryptionKMSKeyId != null && { OutputEncryptionKMSKeyId: input.OutputEncryptionKMSKeyId }),
         ...(input.OutputKey != null && { OutputKey: input.OutputKey }),
-        ...(input.Settings != null && { Settings: serializeAws_json1_1Settings(input.Settings, context) }),
-        ...(input.Subtitles != null && { Subtitles: serializeAws_json1_1Subtitles(input.Subtitles, context) }),
-        ...(input.Tags != null && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
+        ...(input.Settings != null && { Settings: se_Settings(input.Settings, context) }),
+        ...(input.Subtitles != null && { Subtitles: se_Subtitles(input.Subtitles, context) }),
+        ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
         ...(input.TranscriptionJobName != null && { TranscriptionJobName: input.TranscriptionJobName }),
     };
 };
-const serializeAws_json1_1StringTargetList = (input, context) => {
+const se_StringTargetList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1SubtitleFormats = (input, context) => {
+const se_SubtitleFormats = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1Subtitles = (input, context) => {
+const se_Subtitles = (input, context) => {
     return {
-        ...(input.Formats != null && { Formats: serializeAws_json1_1SubtitleFormats(input.Formats, context) }),
+        ...(input.Formats != null && { Formats: se_SubtitleFormats(input.Formats, context) }),
         ...(input.OutputStartIndex != null && { OutputStartIndex: input.OutputStartIndex }),
     };
 };
-const serializeAws_json1_1Tag = (input, context) => {
+const se_Tag = (input, context) => {
     return {
         ...(input.Key != null && { Key: input.Key }),
         ...(input.Value != null && { Value: input.Value }),
     };
 };
-const serializeAws_json1_1TagKeyList = (input, context) => {
+const se_TagKeyList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1TagList = (input, context) => {
+const se_TagList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1Tag(entry, context);
+        return se_Tag(entry, context);
     });
 };
-const serializeAws_json1_1TagResourceRequest = (input, context) => {
+const se_TagResourceRequest = (input, context) => {
     return {
         ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
-        ...(input.Tags != null && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
+        ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
     };
 };
-const serializeAws_json1_1TranscriptFilter = (input, context) => {
+const se_TranscriptFilter = (input, context) => {
     return {
         ...(input.AbsoluteTimeRange != null && {
-            AbsoluteTimeRange: serializeAws_json1_1AbsoluteTimeRange(input.AbsoluteTimeRange, context),
+            AbsoluteTimeRange: se_AbsoluteTimeRange(input.AbsoluteTimeRange, context),
         }),
         ...(input.Negate != null && { Negate: input.Negate }),
         ...(input.ParticipantRole != null && { ParticipantRole: input.ParticipantRole }),
         ...(input.RelativeTimeRange != null && {
-            RelativeTimeRange: serializeAws_json1_1RelativeTimeRange(input.RelativeTimeRange, context),
+            RelativeTimeRange: se_RelativeTimeRange(input.RelativeTimeRange, context),
         }),
-        ...(input.Targets != null && { Targets: serializeAws_json1_1StringTargetList(input.Targets, context) }),
+        ...(input.Targets != null && { Targets: se_StringTargetList(input.Targets, context) }),
         ...(input.TranscriptFilterType != null && { TranscriptFilterType: input.TranscriptFilterType }),
     };
 };
-const serializeAws_json1_1UntagResourceRequest = (input, context) => {
+const se_UntagResourceRequest = (input, context) => {
     return {
         ...(input.ResourceArn != null && { ResourceArn: input.ResourceArn }),
-        ...(input.TagKeys != null && { TagKeys: serializeAws_json1_1TagKeyList(input.TagKeys, context) }),
+        ...(input.TagKeys != null && { TagKeys: se_TagKeyList(input.TagKeys, context) }),
     };
 };
-const serializeAws_json1_1UpdateCallAnalyticsCategoryRequest = (input, context) => {
+const se_UpdateCallAnalyticsCategoryRequest = (input, context) => {
     return {
         ...(input.CategoryName != null && { CategoryName: input.CategoryName }),
         ...(input.InputType != null && { InputType: input.InputType }),
-        ...(input.Rules != null && { Rules: serializeAws_json1_1RuleList(input.Rules, context) }),
+        ...(input.Rules != null && { Rules: se_RuleList(input.Rules, context) }),
     };
 };
-const serializeAws_json1_1UpdateMedicalVocabularyRequest = (input, context) => {
+const se_UpdateMedicalVocabularyRequest = (input, context) => {
     return {
         ...(input.LanguageCode != null && { LanguageCode: input.LanguageCode }),
         ...(input.VocabularyFileUri != null && { VocabularyFileUri: input.VocabularyFileUri }),
         ...(input.VocabularyName != null && { VocabularyName: input.VocabularyName }),
     };
 };
-const serializeAws_json1_1UpdateVocabularyFilterRequest = (input, context) => {
+const se_UpdateVocabularyFilterRequest = (input, context) => {
     return {
         ...(input.DataAccessRoleArn != null && { DataAccessRoleArn: input.DataAccessRoleArn }),
         ...(input.VocabularyFilterFileUri != null && { VocabularyFilterFileUri: input.VocabularyFilterFileUri }),
         ...(input.VocabularyFilterName != null && { VocabularyFilterName: input.VocabularyFilterName }),
-        ...(input.Words != null && { Words: serializeAws_json1_1Words(input.Words, context) }),
+        ...(input.Words != null && { Words: se_Words(input.Words, context) }),
     };
 };
-const serializeAws_json1_1UpdateVocabularyRequest = (input, context) => {
+const se_UpdateVocabularyRequest = (input, context) => {
     return {
         ...(input.DataAccessRoleArn != null && { DataAccessRoleArn: input.DataAccessRoleArn }),
         ...(input.LanguageCode != null && { LanguageCode: input.LanguageCode }),
-        ...(input.Phrases != null && { Phrases: serializeAws_json1_1Phrases(input.Phrases, context) }),
+        ...(input.Phrases != null && { Phrases: se_Phrases(input.Phrases, context) }),
         ...(input.VocabularyFileUri != null && { VocabularyFileUri: input.VocabularyFileUri }),
         ...(input.VocabularyName != null && { VocabularyName: input.VocabularyName }),
     };
 };
-const serializeAws_json1_1Words = (input, context) => {
+const se_Words = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const deserializeAws_json1_1AbsoluteTimeRange = (output, context) => {
+const de_AbsoluteTimeRange = (output, context) => {
     return {
         EndTime: __expectLong(output.EndTime),
         First: __expectLong(output.First),
@@ -2585,18 +2569,16 @@ const deserializeAws_json1_1AbsoluteTimeRange = (output, context) => {
         StartTime: __expectLong(output.StartTime),
     };
 };
-const deserializeAws_json1_1BadRequestException = (output, context) => {
+const de_BadRequestException = (output, context) => {
     return {
         Message: __expectString(output.Message),
     };
 };
-const deserializeAws_json1_1CallAnalyticsJob = (output, context) => {
+const de_CallAnalyticsJob = (output, context) => {
     return {
         CallAnalyticsJobName: __expectString(output.CallAnalyticsJobName),
         CallAnalyticsJobStatus: __expectString(output.CallAnalyticsJobStatus),
-        ChannelDefinitions: output.ChannelDefinitions != null
-            ? deserializeAws_json1_1ChannelDefinitions(output.ChannelDefinitions, context)
-            : undefined,
+        ChannelDefinitions: output.ChannelDefinitions != null ? de_ChannelDefinitions(output.ChannelDefinitions, context) : undefined,
         CompletionTime: output.CompletionTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CompletionTime)))
             : undefined,
@@ -2607,43 +2589,37 @@ const deserializeAws_json1_1CallAnalyticsJob = (output, context) => {
         FailureReason: __expectString(output.FailureReason),
         IdentifiedLanguageScore: __limitedParseFloat32(output.IdentifiedLanguageScore),
         LanguageCode: __expectString(output.LanguageCode),
-        Media: output.Media != null ? deserializeAws_json1_1Media(output.Media, context) : undefined,
+        Media: output.Media != null ? de_Media(output.Media, context) : undefined,
         MediaFormat: __expectString(output.MediaFormat),
         MediaSampleRateHertz: __expectInt32(output.MediaSampleRateHertz),
-        Settings: output.Settings != null ? deserializeAws_json1_1CallAnalyticsJobSettings(output.Settings, context) : undefined,
+        Settings: output.Settings != null ? de_CallAnalyticsJobSettings(output.Settings, context) : undefined,
         StartTime: output.StartTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartTime))) : undefined,
-        Transcript: output.Transcript != null ? deserializeAws_json1_1Transcript(output.Transcript, context) : undefined,
+        Transcript: output.Transcript != null ? de_Transcript(output.Transcript, context) : undefined,
     };
 };
-const deserializeAws_json1_1CallAnalyticsJobSettings = (output, context) => {
+const de_CallAnalyticsJobSettings = (output, context) => {
     return {
-        ContentRedaction: output.ContentRedaction != null
-            ? deserializeAws_json1_1ContentRedaction(output.ContentRedaction, context)
-            : undefined,
-        LanguageIdSettings: output.LanguageIdSettings != null
-            ? deserializeAws_json1_1LanguageIdSettingsMap(output.LanguageIdSettings, context)
-            : undefined,
+        ContentRedaction: output.ContentRedaction != null ? de_ContentRedaction(output.ContentRedaction, context) : undefined,
+        LanguageIdSettings: output.LanguageIdSettings != null ? de_LanguageIdSettingsMap(output.LanguageIdSettings, context) : undefined,
         LanguageModelName: __expectString(output.LanguageModelName),
-        LanguageOptions: output.LanguageOptions != null
-            ? deserializeAws_json1_1LanguageOptions(output.LanguageOptions, context)
-            : undefined,
+        LanguageOptions: output.LanguageOptions != null ? de_LanguageOptions(output.LanguageOptions, context) : undefined,
         VocabularyFilterMethod: __expectString(output.VocabularyFilterMethod),
         VocabularyFilterName: __expectString(output.VocabularyFilterName),
         VocabularyName: __expectString(output.VocabularyName),
     };
 };
-const deserializeAws_json1_1CallAnalyticsJobSummaries = (output, context) => {
+const de_CallAnalyticsJobSummaries = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1CallAnalyticsJobSummary(entry, context);
+        return de_CallAnalyticsJobSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1CallAnalyticsJobSummary = (output, context) => {
+const de_CallAnalyticsJobSummary = (output, context) => {
     return {
         CallAnalyticsJobName: __expectString(output.CallAnalyticsJobName),
         CallAnalyticsJobStatus: __expectString(output.CallAnalyticsJobStatus),
@@ -2658,7 +2634,7 @@ const deserializeAws_json1_1CallAnalyticsJobSummary = (output, context) => {
         StartTime: output.StartTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartTime))) : undefined,
     };
 };
-const deserializeAws_json1_1CategoryProperties = (output, context) => {
+const de_CategoryProperties = (output, context) => {
     return {
         CategoryName: __expectString(output.CategoryName),
         CreateTime: output.CreateTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreateTime))) : undefined,
@@ -2666,68 +2642,64 @@ const deserializeAws_json1_1CategoryProperties = (output, context) => {
         LastUpdateTime: output.LastUpdateTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.LastUpdateTime)))
             : undefined,
-        Rules: output.Rules != null ? deserializeAws_json1_1RuleList(output.Rules, context) : undefined,
+        Rules: output.Rules != null ? de_RuleList(output.Rules, context) : undefined,
     };
 };
-const deserializeAws_json1_1CategoryPropertiesList = (output, context) => {
+const de_CategoryPropertiesList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1CategoryProperties(entry, context);
+        return de_CategoryProperties(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ChannelDefinition = (output, context) => {
+const de_ChannelDefinition = (output, context) => {
     return {
         ChannelId: __expectInt32(output.ChannelId),
         ParticipantRole: __expectString(output.ParticipantRole),
     };
 };
-const deserializeAws_json1_1ChannelDefinitions = (output, context) => {
+const de_ChannelDefinitions = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ChannelDefinition(entry, context);
+        return de_ChannelDefinition(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ConflictException = (output, context) => {
+const de_ConflictException = (output, context) => {
     return {
         Message: __expectString(output.Message),
     };
 };
-const deserializeAws_json1_1ContentRedaction = (output, context) => {
+const de_ContentRedaction = (output, context) => {
     return {
-        PiiEntityTypes: output.PiiEntityTypes != null ? deserializeAws_json1_1PiiEntityTypes(output.PiiEntityTypes, context) : undefined,
+        PiiEntityTypes: output.PiiEntityTypes != null ? de_PiiEntityTypes(output.PiiEntityTypes, context) : undefined,
         RedactionOutput: __expectString(output.RedactionOutput),
         RedactionType: __expectString(output.RedactionType),
     };
 };
-const deserializeAws_json1_1CreateCallAnalyticsCategoryResponse = (output, context) => {
+const de_CreateCallAnalyticsCategoryResponse = (output, context) => {
     return {
-        CategoryProperties: output.CategoryProperties != null
-            ? deserializeAws_json1_1CategoryProperties(output.CategoryProperties, context)
-            : undefined,
+        CategoryProperties: output.CategoryProperties != null ? de_CategoryProperties(output.CategoryProperties, context) : undefined,
     };
 };
-const deserializeAws_json1_1CreateLanguageModelResponse = (output, context) => {
+const de_CreateLanguageModelResponse = (output, context) => {
     return {
         BaseModelName: __expectString(output.BaseModelName),
-        InputDataConfig: output.InputDataConfig != null
-            ? deserializeAws_json1_1InputDataConfig(output.InputDataConfig, context)
-            : undefined,
+        InputDataConfig: output.InputDataConfig != null ? de_InputDataConfig(output.InputDataConfig, context) : undefined,
         LanguageCode: __expectString(output.LanguageCode),
         ModelName: __expectString(output.ModelName),
         ModelStatus: __expectString(output.ModelStatus),
     };
 };
-const deserializeAws_json1_1CreateMedicalVocabularyResponse = (output, context) => {
+const de_CreateMedicalVocabularyResponse = (output, context) => {
     return {
         FailureReason: __expectString(output.FailureReason),
         LanguageCode: __expectString(output.LanguageCode),
@@ -2738,7 +2710,7 @@ const deserializeAws_json1_1CreateMedicalVocabularyResponse = (output, context)
         VocabularyState: __expectString(output.VocabularyState),
     };
 };
-const deserializeAws_json1_1CreateVocabularyFilterResponse = (output, context) => {
+const de_CreateVocabularyFilterResponse = (output, context) => {
     return {
         LanguageCode: __expectString(output.LanguageCode),
         LastModifiedTime: output.LastModifiedTime != null
@@ -2747,7 +2719,7 @@ const deserializeAws_json1_1CreateVocabularyFilterResponse = (output, context) =
         VocabularyFilterName: __expectString(output.VocabularyFilterName),
     };
 };
-const deserializeAws_json1_1CreateVocabularyResponse = (output, context) => {
+const de_CreateVocabularyResponse = (output, context) => {
     return {
         FailureReason: __expectString(output.FailureReason),
         LanguageCode: __expectString(output.LanguageCode),
@@ -2758,39 +2730,35 @@ const deserializeAws_json1_1CreateVocabularyResponse = (output, context) => {
         VocabularyState: __expectString(output.VocabularyState),
     };
 };
-const deserializeAws_json1_1DeleteCallAnalyticsCategoryResponse = (output, context) => {
+const de_DeleteCallAnalyticsCategoryResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1DeleteCallAnalyticsJobResponse = (output, context) => {
+const de_DeleteCallAnalyticsJobResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1DescribeLanguageModelResponse = (output, context) => {
+const de_DescribeLanguageModelResponse = (output, context) => {
     return {
-        LanguageModel: output.LanguageModel != null ? deserializeAws_json1_1LanguageModel(output.LanguageModel, context) : undefined,
+        LanguageModel: output.LanguageModel != null ? de_LanguageModel(output.LanguageModel, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetCallAnalyticsCategoryResponse = (output, context) => {
+const de_GetCallAnalyticsCategoryResponse = (output, context) => {
     return {
-        CategoryProperties: output.CategoryProperties != null
-            ? deserializeAws_json1_1CategoryProperties(output.CategoryProperties, context)
-            : undefined,
+        CategoryProperties: output.CategoryProperties != null ? de_CategoryProperties(output.CategoryProperties, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetCallAnalyticsJobResponse = (output, context) => {
+const de_GetCallAnalyticsJobResponse = (output, context) => {
     return {
-        CallAnalyticsJob: output.CallAnalyticsJob != null
-            ? deserializeAws_json1_1CallAnalyticsJob(output.CallAnalyticsJob, context)
-            : undefined,
+        CallAnalyticsJob: output.CallAnalyticsJob != null ? de_CallAnalyticsJob(output.CallAnalyticsJob, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetMedicalTranscriptionJobResponse = (output, context) => {
+const de_GetMedicalTranscriptionJobResponse = (output, context) => {
     return {
         MedicalTranscriptionJob: output.MedicalTranscriptionJob != null
-            ? deserializeAws_json1_1MedicalTranscriptionJob(output.MedicalTranscriptionJob, context)
+            ? de_MedicalTranscriptionJob(output.MedicalTranscriptionJob, context)
             : undefined,
     };
 };
-const deserializeAws_json1_1GetMedicalVocabularyResponse = (output, context) => {
+const de_GetMedicalVocabularyResponse = (output, context) => {
     return {
         DownloadUri: __expectString(output.DownloadUri),
         FailureReason: __expectString(output.FailureReason),
@@ -2802,14 +2770,12 @@ const deserializeAws_json1_1GetMedicalVocabularyResponse = (output, context) =>
         VocabularyState: __expectString(output.VocabularyState),
     };
 };
-const deserializeAws_json1_1GetTranscriptionJobResponse = (output, context) => {
+const de_GetTranscriptionJobResponse = (output, context) => {
     return {
-        TranscriptionJob: output.TranscriptionJob != null
-            ? deserializeAws_json1_1TranscriptionJob(output.TranscriptionJob, context)
-            : undefined,
+        TranscriptionJob: output.TranscriptionJob != null ? de_TranscriptionJob(output.TranscriptionJob, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetVocabularyFilterResponse = (output, context) => {
+const de_GetVocabularyFilterResponse = (output, context) => {
     return {
         DownloadUri: __expectString(output.DownloadUri),
         LanguageCode: __expectString(output.LanguageCode),
@@ -2819,7 +2785,7 @@ const deserializeAws_json1_1GetVocabularyFilterResponse = (output, context) => {
         VocabularyFilterName: __expectString(output.VocabularyFilterName),
     };
 };
-const deserializeAws_json1_1GetVocabularyResponse = (output, context) => {
+const de_GetVocabularyResponse = (output, context) => {
     return {
         DownloadUri: __expectString(output.DownloadUri),
         FailureReason: __expectString(output.FailureReason),
@@ -2831,78 +2797,72 @@ const deserializeAws_json1_1GetVocabularyResponse = (output, context) => {
         VocabularyState: __expectString(output.VocabularyState),
     };
 };
-const deserializeAws_json1_1InputDataConfig = (output, context) => {
+const de_InputDataConfig = (output, context) => {
     return {
         DataAccessRoleArn: __expectString(output.DataAccessRoleArn),
         S3Uri: __expectString(output.S3Uri),
         TuningDataS3Uri: __expectString(output.TuningDataS3Uri),
     };
 };
-const deserializeAws_json1_1InternalFailureException = (output, context) => {
+const de_InternalFailureException = (output, context) => {
     return {
         Message: __expectString(output.Message),
     };
 };
-const deserializeAws_json1_1InterruptionFilter = (output, context) => {
+const de_InterruptionFilter = (output, context) => {
     return {
-        AbsoluteTimeRange: output.AbsoluteTimeRange != null
-            ? deserializeAws_json1_1AbsoluteTimeRange(output.AbsoluteTimeRange, context)
-            : undefined,
+        AbsoluteTimeRange: output.AbsoluteTimeRange != null ? de_AbsoluteTimeRange(output.AbsoluteTimeRange, context) : undefined,
         Negate: __expectBoolean(output.Negate),
         ParticipantRole: __expectString(output.ParticipantRole),
-        RelativeTimeRange: output.RelativeTimeRange != null
-            ? deserializeAws_json1_1RelativeTimeRange(output.RelativeTimeRange, context)
-            : undefined,
+        RelativeTimeRange: output.RelativeTimeRange != null ? de_RelativeTimeRange(output.RelativeTimeRange, context) : undefined,
         Threshold: __expectLong(output.Threshold),
     };
 };
-const deserializeAws_json1_1JobExecutionSettings = (output, context) => {
+const de_JobExecutionSettings = (output, context) => {
     return {
         AllowDeferredExecution: __expectBoolean(output.AllowDeferredExecution),
         DataAccessRoleArn: __expectString(output.DataAccessRoleArn),
     };
 };
-const deserializeAws_json1_1LanguageCodeItem = (output, context) => {
+const de_LanguageCodeItem = (output, context) => {
     return {
         DurationInSeconds: __limitedParseFloat32(output.DurationInSeconds),
         LanguageCode: __expectString(output.LanguageCode),
     };
 };
-const deserializeAws_json1_1LanguageCodeList = (output, context) => {
+const de_LanguageCodeList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1LanguageCodeItem(entry, context);
+        return de_LanguageCodeItem(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1LanguageIdSettings = (output, context) => {
+const de_LanguageIdSettings = (output, context) => {
     return {
         LanguageModelName: __expectString(output.LanguageModelName),
         VocabularyFilterName: __expectString(output.VocabularyFilterName),
         VocabularyName: __expectString(output.VocabularyName),
     };
 };
-const deserializeAws_json1_1LanguageIdSettingsMap = (output, context) => {
+const de_LanguageIdSettingsMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = deserializeAws_json1_1LanguageIdSettings(value, context);
+        acc[key] = de_LanguageIdSettings(value, context);
         return acc;
     }, {});
 };
-const deserializeAws_json1_1LanguageModel = (output, context) => {
+const de_LanguageModel = (output, context) => {
     return {
         BaseModelName: __expectString(output.BaseModelName),
         CreateTime: output.CreateTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreateTime))) : undefined,
         FailureReason: __expectString(output.FailureReason),
-        InputDataConfig: output.InputDataConfig != null
-            ? deserializeAws_json1_1InputDataConfig(output.InputDataConfig, context)
-            : undefined,
+        InputDataConfig: output.InputDataConfig != null ? de_InputDataConfig(output.InputDataConfig, context) : undefined,
         LanguageCode: __expectString(output.LanguageCode),
         LastModifiedTime: output.LastModifiedTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.LastModifiedTime)))
@@ -2912,7 +2872,7 @@ const deserializeAws_json1_1LanguageModel = (output, context) => {
         UpgradeAvailability: __expectBoolean(output.UpgradeAvailability),
     };
 };
-const deserializeAws_json1_1LanguageOptions = (output, context) => {
+const de_LanguageOptions = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2923,90 +2883,88 @@ const deserializeAws_json1_1LanguageOptions = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1LimitExceededException = (output, context) => {
+const de_LimitExceededException = (output, context) => {
     return {
         Message: __expectString(output.Message),
     };
 };
-const deserializeAws_json1_1ListCallAnalyticsCategoriesResponse = (output, context) => {
+const de_ListCallAnalyticsCategoriesResponse = (output, context) => {
     return {
-        Categories: output.Categories != null ? deserializeAws_json1_1CategoryPropertiesList(output.Categories, context) : undefined,
+        Categories: output.Categories != null ? de_CategoryPropertiesList(output.Categories, context) : undefined,
         NextToken: __expectString(output.NextToken),
     };
 };
-const deserializeAws_json1_1ListCallAnalyticsJobsResponse = (output, context) => {
+const de_ListCallAnalyticsJobsResponse = (output, context) => {
     return {
         CallAnalyticsJobSummaries: output.CallAnalyticsJobSummaries != null
-            ? deserializeAws_json1_1CallAnalyticsJobSummaries(output.CallAnalyticsJobSummaries, context)
+            ? de_CallAnalyticsJobSummaries(output.CallAnalyticsJobSummaries, context)
             : undefined,
         NextToken: __expectString(output.NextToken),
         Status: __expectString(output.Status),
     };
 };
-const deserializeAws_json1_1ListLanguageModelsResponse = (output, context) => {
+const de_ListLanguageModelsResponse = (output, context) => {
     return {
-        Models: output.Models != null ? deserializeAws_json1_1Models(output.Models, context) : undefined,
+        Models: output.Models != null ? de_Models(output.Models, context) : undefined,
         NextToken: __expectString(output.NextToken),
     };
 };
-const deserializeAws_json1_1ListMedicalTranscriptionJobsResponse = (output, context) => {
+const de_ListMedicalTranscriptionJobsResponse = (output, context) => {
     return {
         MedicalTranscriptionJobSummaries: output.MedicalTranscriptionJobSummaries != null
-            ? deserializeAws_json1_1MedicalTranscriptionJobSummaries(output.MedicalTranscriptionJobSummaries, context)
+            ? de_MedicalTranscriptionJobSummaries(output.MedicalTranscriptionJobSummaries, context)
             : undefined,
         NextToken: __expectString(output.NextToken),
         Status: __expectString(output.Status),
     };
 };
-const deserializeAws_json1_1ListMedicalVocabulariesResponse = (output, context) => {
+const de_ListMedicalVocabulariesResponse = (output, context) => {
     return {
         NextToken: __expectString(output.NextToken),
         Status: __expectString(output.Status),
-        Vocabularies: output.Vocabularies != null ? deserializeAws_json1_1Vocabularies(output.Vocabularies, context) : undefined,
+        Vocabularies: output.Vocabularies != null ? de_Vocabularies(output.Vocabularies, context) : undefined,
     };
 };
-const deserializeAws_json1_1ListTagsForResourceResponse = (output, context) => {
+const de_ListTagsForResourceResponse = (output, context) => {
     return {
         ResourceArn: __expectString(output.ResourceArn),
-        Tags: output.Tags != null ? deserializeAws_json1_1TagList(output.Tags, context) : undefined,
+        Tags: output.Tags != null ? de_TagList(output.Tags, context) : undefined,
     };
 };
-const deserializeAws_json1_1ListTranscriptionJobsResponse = (output, context) => {
+const de_ListTranscriptionJobsResponse = (output, context) => {
     return {
         NextToken: __expectString(output.NextToken),
         Status: __expectString(output.Status),
         TranscriptionJobSummaries: output.TranscriptionJobSummaries != null
-            ? deserializeAws_json1_1TranscriptionJobSummaries(output.TranscriptionJobSummaries, context)
+            ? de_TranscriptionJobSummaries(output.TranscriptionJobSummaries, context)
             : undefined,
     };
 };
-const deserializeAws_json1_1ListVocabulariesResponse = (output, context) => {
+const de_ListVocabulariesResponse = (output, context) => {
     return {
         NextToken: __expectString(output.NextToken),
         Status: __expectString(output.Status),
-        Vocabularies: output.Vocabularies != null ? deserializeAws_json1_1Vocabularies(output.Vocabularies, context) : undefined,
+        Vocabularies: output.Vocabularies != null ? de_Vocabularies(output.Vocabularies, context) : undefined,
     };
 };
-const deserializeAws_json1_1ListVocabularyFiltersResponse = (output, context) => {
+const de_ListVocabularyFiltersResponse = (output, context) => {
     return {
         NextToken: __expectString(output.NextToken),
-        VocabularyFilters: output.VocabularyFilters != null
-            ? deserializeAws_json1_1VocabularyFilters(output.VocabularyFilters, context)
-            : undefined,
+        VocabularyFilters: output.VocabularyFilters != null ? de_VocabularyFilters(output.VocabularyFilters, context) : undefined,
     };
 };
-const deserializeAws_json1_1Media = (output, context) => {
+const de_Media = (output, context) => {
     return {
         MediaFileUri: __expectString(output.MediaFileUri),
         RedactedMediaFileUri: __expectString(output.RedactedMediaFileUri),
     };
 };
-const deserializeAws_json1_1MedicalTranscript = (output, context) => {
+const de_MedicalTranscript = (output, context) => {
     return {
         TranscriptFileUri: __expectString(output.TranscriptFileUri),
     };
 };
-const deserializeAws_json1_1MedicalTranscriptionJob = (output, context) => {
+const de_MedicalTranscriptionJob = (output, context) => {
     return {
         CompletionTime: output.CompletionTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CompletionTime)))
@@ -3017,31 +2975,31 @@ const deserializeAws_json1_1MedicalTranscriptionJob = (output, context) => {
             : undefined,
         FailureReason: __expectString(output.FailureReason),
         LanguageCode: __expectString(output.LanguageCode),
-        Media: output.Media != null ? deserializeAws_json1_1Media(output.Media, context) : undefined,
+        Media: output.Media != null ? de_Media(output.Media, context) : undefined,
         MediaFormat: __expectString(output.MediaFormat),
         MediaSampleRateHertz: __expectInt32(output.MediaSampleRateHertz),
         MedicalTranscriptionJobName: __expectString(output.MedicalTranscriptionJobName),
-        Settings: output.Settings != null ? deserializeAws_json1_1MedicalTranscriptionSetting(output.Settings, context) : undefined,
+        Settings: output.Settings != null ? de_MedicalTranscriptionSetting(output.Settings, context) : undefined,
         Specialty: __expectString(output.Specialty),
         StartTime: output.StartTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartTime))) : undefined,
-        Tags: output.Tags != null ? deserializeAws_json1_1TagList(output.Tags, context) : undefined,
-        Transcript: output.Transcript != null ? deserializeAws_json1_1MedicalTranscript(output.Transcript, context) : undefined,
+        Tags: output.Tags != null ? de_TagList(output.Tags, context) : undefined,
+        Transcript: output.Transcript != null ? de_MedicalTranscript(output.Transcript, context) : undefined,
         TranscriptionJobStatus: __expectString(output.TranscriptionJobStatus),
         Type: __expectString(output.Type),
     };
 };
-const deserializeAws_json1_1MedicalTranscriptionJobSummaries = (output, context) => {
+const de_MedicalTranscriptionJobSummaries = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1MedicalTranscriptionJobSummary(entry, context);
+        return de_MedicalTranscriptionJobSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1MedicalTranscriptionJobSummary = (output, context) => {
+const de_MedicalTranscriptionJobSummary = (output, context) => {
     return {
         CompletionTime: output.CompletionTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CompletionTime)))
@@ -3060,7 +3018,7 @@ const deserializeAws_json1_1MedicalTranscriptionJobSummary = (output, context) =
         Type: __expectString(output.Type),
     };
 };
-const deserializeAws_json1_1MedicalTranscriptionSetting = (output, context) => {
+const de_MedicalTranscriptionSetting = (output, context) => {
     return {
         ChannelIdentification: __expectBoolean(output.ChannelIdentification),
         MaxAlternatives: __expectInt32(output.MaxAlternatives),
@@ -3070,40 +3028,36 @@ const deserializeAws_json1_1MedicalTranscriptionSetting = (output, context) => {
         VocabularyName: __expectString(output.VocabularyName),
     };
 };
-const deserializeAws_json1_1Models = (output, context) => {
+const de_Models = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1LanguageModel(entry, context);
+        return de_LanguageModel(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ModelSettings = (output, context) => {
+const de_ModelSettings = (output, context) => {
     return {
         LanguageModelName: __expectString(output.LanguageModelName),
     };
 };
-const deserializeAws_json1_1NonTalkTimeFilter = (output, context) => {
+const de_NonTalkTimeFilter = (output, context) => {
     return {
-        AbsoluteTimeRange: output.AbsoluteTimeRange != null
-            ? deserializeAws_json1_1AbsoluteTimeRange(output.AbsoluteTimeRange, context)
-            : undefined,
+        AbsoluteTimeRange: output.AbsoluteTimeRange != null ? de_AbsoluteTimeRange(output.AbsoluteTimeRange, context) : undefined,
         Negate: __expectBoolean(output.Negate),
-        RelativeTimeRange: output.RelativeTimeRange != null
-            ? deserializeAws_json1_1RelativeTimeRange(output.RelativeTimeRange, context)
-            : undefined,
+        RelativeTimeRange: output.RelativeTimeRange != null ? de_RelativeTimeRange(output.RelativeTimeRange, context) : undefined,
         Threshold: __expectLong(output.Threshold),
     };
 };
-const deserializeAws_json1_1NotFoundException = (output, context) => {
+const de_NotFoundException = (output, context) => {
     return {
         Message: __expectString(output.Message),
     };
 };
-const deserializeAws_json1_1PiiEntityTypes = (output, context) => {
+const de_PiiEntityTypes = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -3114,7 +3068,7 @@ const deserializeAws_json1_1PiiEntityTypes = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1RelativeTimeRange = (output, context) => {
+const de_RelativeTimeRange = (output, context) => {
     return {
         EndPercentage: __expectInt32(output.EndPercentage),
         First: __expectInt32(output.First),
@@ -3122,54 +3076,50 @@ const deserializeAws_json1_1RelativeTimeRange = (output, context) => {
         StartPercentage: __expectInt32(output.StartPercentage),
     };
 };
-const deserializeAws_json1_1Rule = (output, context) => {
+const de_Rule = (output, context) => {
     if (output.InterruptionFilter != null) {
         return {
-            InterruptionFilter: deserializeAws_json1_1InterruptionFilter(output.InterruptionFilter, context),
+            InterruptionFilter: de_InterruptionFilter(output.InterruptionFilter, context),
         };
     }
     if (output.NonTalkTimeFilter != null) {
         return {
-            NonTalkTimeFilter: deserializeAws_json1_1NonTalkTimeFilter(output.NonTalkTimeFilter, context),
+            NonTalkTimeFilter: de_NonTalkTimeFilter(output.NonTalkTimeFilter, context),
         };
     }
     if (output.SentimentFilter != null) {
         return {
-            SentimentFilter: deserializeAws_json1_1SentimentFilter(output.SentimentFilter, context),
+            SentimentFilter: de_SentimentFilter(output.SentimentFilter, context),
         };
     }
     if (output.TranscriptFilter != null) {
         return {
-            TranscriptFilter: deserializeAws_json1_1TranscriptFilter(output.TranscriptFilter, context),
+            TranscriptFilter: de_TranscriptFilter(output.TranscriptFilter, context),
         };
     }
     return { $unknown: Object.entries(output)[0] };
 };
-const deserializeAws_json1_1RuleList = (output, context) => {
+const de_RuleList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Rule(__expectUnion(entry), context);
+        return de_Rule(__expectUnion(entry), context);
     });
     return retVal;
 };
-const deserializeAws_json1_1SentimentFilter = (output, context) => {
+const de_SentimentFilter = (output, context) => {
     return {
-        AbsoluteTimeRange: output.AbsoluteTimeRange != null
-            ? deserializeAws_json1_1AbsoluteTimeRange(output.AbsoluteTimeRange, context)
-            : undefined,
+        AbsoluteTimeRange: output.AbsoluteTimeRange != null ? de_AbsoluteTimeRange(output.AbsoluteTimeRange, context) : undefined,
         Negate: __expectBoolean(output.Negate),
         ParticipantRole: __expectString(output.ParticipantRole),
-        RelativeTimeRange: output.RelativeTimeRange != null
-            ? deserializeAws_json1_1RelativeTimeRange(output.RelativeTimeRange, context)
-            : undefined,
-        Sentiments: output.Sentiments != null ? deserializeAws_json1_1SentimentValueList(output.Sentiments, context) : undefined,
+        RelativeTimeRange: output.RelativeTimeRange != null ? de_RelativeTimeRange(output.RelativeTimeRange, context) : undefined,
+        Sentiments: output.Sentiments != null ? de_SentimentValueList(output.Sentiments, context) : undefined,
     };
 };
-const deserializeAws_json1_1SentimentValueList = (output, context) => {
+const de_SentimentValueList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -3180,7 +3130,7 @@ const deserializeAws_json1_1SentimentValueList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1Settings = (output, context) => {
+const de_Settings = (output, context) => {
     return {
         ChannelIdentification: __expectBoolean(output.ChannelIdentification),
         MaxAlternatives: __expectInt32(output.MaxAlternatives),
@@ -3192,28 +3142,24 @@ const deserializeAws_json1_1Settings = (output, context) => {
         VocabularyName: __expectString(output.VocabularyName),
     };
 };
-const deserializeAws_json1_1StartCallAnalyticsJobResponse = (output, context) => {
+const de_StartCallAnalyticsJobResponse = (output, context) => {
     return {
-        CallAnalyticsJob: output.CallAnalyticsJob != null
-            ? deserializeAws_json1_1CallAnalyticsJob(output.CallAnalyticsJob, context)
-            : undefined,
+        CallAnalyticsJob: output.CallAnalyticsJob != null ? de_CallAnalyticsJob(output.CallAnalyticsJob, context) : undefined,
     };
 };
-const deserializeAws_json1_1StartMedicalTranscriptionJobResponse = (output, context) => {
+const de_StartMedicalTranscriptionJobResponse = (output, context) => {
     return {
         MedicalTranscriptionJob: output.MedicalTranscriptionJob != null
-            ? deserializeAws_json1_1MedicalTranscriptionJob(output.MedicalTranscriptionJob, context)
+            ? de_MedicalTranscriptionJob(output.MedicalTranscriptionJob, context)
             : undefined,
     };
 };
-const deserializeAws_json1_1StartTranscriptionJobResponse = (output, context) => {
+const de_StartTranscriptionJobResponse = (output, context) => {
     return {
-        TranscriptionJob: output.TranscriptionJob != null
-            ? deserializeAws_json1_1TranscriptionJob(output.TranscriptionJob, context)
-            : undefined,
+        TranscriptionJob: output.TranscriptionJob != null ? de_TranscriptionJob(output.TranscriptionJob, context) : undefined,
     };
 };
-const deserializeAws_json1_1StringTargetList = (output, context) => {
+const de_StringTargetList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -3224,7 +3170,7 @@ const deserializeAws_json1_1StringTargetList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1SubtitleFileUris = (output, context) => {
+const de_SubtitleFileUris = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -3235,7 +3181,7 @@ const deserializeAws_json1_1SubtitleFileUris = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1SubtitleFormats = (output, context) => {
+const de_SubtitleFormats = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -3246,63 +3192,55 @@ const deserializeAws_json1_1SubtitleFormats = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1SubtitlesOutput = (output, context) => {
+const de_SubtitlesOutput = (output, context) => {
     return {
-        Formats: output.Formats != null ? deserializeAws_json1_1SubtitleFormats(output.Formats, context) : undefined,
+        Formats: output.Formats != null ? de_SubtitleFormats(output.Formats, context) : undefined,
         OutputStartIndex: __expectInt32(output.OutputStartIndex),
-        SubtitleFileUris: output.SubtitleFileUris != null
-            ? deserializeAws_json1_1SubtitleFileUris(output.SubtitleFileUris, context)
-            : undefined,
+        SubtitleFileUris: output.SubtitleFileUris != null ? de_SubtitleFileUris(output.SubtitleFileUris, context) : undefined,
     };
 };
-const deserializeAws_json1_1Tag = (output, context) => {
+const de_Tag = (output, context) => {
     return {
         Key: __expectString(output.Key),
         Value: __expectString(output.Value),
     };
 };
-const deserializeAws_json1_1TagList = (output, context) => {
+const de_TagList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Tag(entry, context);
+        return de_Tag(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1TagResourceResponse = (output, context) => {
+const de_TagResourceResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1Transcript = (output, context) => {
+const de_Transcript = (output, context) => {
     return {
         RedactedTranscriptFileUri: __expectString(output.RedactedTranscriptFileUri),
         TranscriptFileUri: __expectString(output.TranscriptFileUri),
     };
 };
-const deserializeAws_json1_1TranscriptFilter = (output, context) => {
+const de_TranscriptFilter = (output, context) => {
     return {
-        AbsoluteTimeRange: output.AbsoluteTimeRange != null
-            ? deserializeAws_json1_1AbsoluteTimeRange(output.AbsoluteTimeRange, context)
-            : undefined,
+        AbsoluteTimeRange: output.AbsoluteTimeRange != null ? de_AbsoluteTimeRange(output.AbsoluteTimeRange, context) : undefined,
         Negate: __expectBoolean(output.Negate),
         ParticipantRole: __expectString(output.ParticipantRole),
-        RelativeTimeRange: output.RelativeTimeRange != null
-            ? deserializeAws_json1_1RelativeTimeRange(output.RelativeTimeRange, context)
-            : undefined,
-        Targets: output.Targets != null ? deserializeAws_json1_1StringTargetList(output.Targets, context) : undefined,
+        RelativeTimeRange: output.RelativeTimeRange != null ? de_RelativeTimeRange(output.RelativeTimeRange, context) : undefined,
+        Targets: output.Targets != null ? de_StringTargetList(output.Targets, context) : undefined,
         TranscriptFilterType: __expectString(output.TranscriptFilterType),
     };
 };
-const deserializeAws_json1_1TranscriptionJob = (output, context) => {
+const de_TranscriptionJob = (output, context) => {
     return {
         CompletionTime: output.CompletionTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CompletionTime)))
             : undefined,
-        ContentRedaction: output.ContentRedaction != null
-            ? deserializeAws_json1_1ContentRedaction(output.ContentRedaction, context)
-            : undefined,
+        ContentRedaction: output.ContentRedaction != null ? de_ContentRedaction(output.ContentRedaction, context) : undefined,
         CreationTime: output.CreationTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreationTime)))
             : undefined,
@@ -3310,49 +3248,41 @@ const deserializeAws_json1_1TranscriptionJob = (output, context) => {
         IdentifiedLanguageScore: __limitedParseFloat32(output.IdentifiedLanguageScore),
         IdentifyLanguage: __expectBoolean(output.IdentifyLanguage),
         IdentifyMultipleLanguages: __expectBoolean(output.IdentifyMultipleLanguages),
-        JobExecutionSettings: output.JobExecutionSettings != null
-            ? deserializeAws_json1_1JobExecutionSettings(output.JobExecutionSettings, context)
-            : undefined,
+        JobExecutionSettings: output.JobExecutionSettings != null ? de_JobExecutionSettings(output.JobExecutionSettings, context) : undefined,
         LanguageCode: __expectString(output.LanguageCode),
-        LanguageCodes: output.LanguageCodes != null ? deserializeAws_json1_1LanguageCodeList(output.LanguageCodes, context) : undefined,
-        LanguageIdSettings: output.LanguageIdSettings != null
-            ? deserializeAws_json1_1LanguageIdSettingsMap(output.LanguageIdSettings, context)
-            : undefined,
-        LanguageOptions: output.LanguageOptions != null
-            ? deserializeAws_json1_1LanguageOptions(output.LanguageOptions, context)
-            : undefined,
-        Media: output.Media != null ? deserializeAws_json1_1Media(output.Media, context) : undefined,
+        LanguageCodes: output.LanguageCodes != null ? de_LanguageCodeList(output.LanguageCodes, context) : undefined,
+        LanguageIdSettings: output.LanguageIdSettings != null ? de_LanguageIdSettingsMap(output.LanguageIdSettings, context) : undefined,
+        LanguageOptions: output.LanguageOptions != null ? de_LanguageOptions(output.LanguageOptions, context) : undefined,
+        Media: output.Media != null ? de_Media(output.Media, context) : undefined,
         MediaFormat: __expectString(output.MediaFormat),
         MediaSampleRateHertz: __expectInt32(output.MediaSampleRateHertz),
-        ModelSettings: output.ModelSettings != null ? deserializeAws_json1_1ModelSettings(output.ModelSettings, context) : undefined,
-        Settings: output.Settings != null ? deserializeAws_json1_1Settings(output.Settings, context) : undefined,
+        ModelSettings: output.ModelSettings != null ? de_ModelSettings(output.ModelSettings, context) : undefined,
+        Settings: output.Settings != null ? de_Settings(output.Settings, context) : undefined,
         StartTime: output.StartTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartTime))) : undefined,
-        Subtitles: output.Subtitles != null ? deserializeAws_json1_1SubtitlesOutput(output.Subtitles, context) : undefined,
-        Tags: output.Tags != null ? deserializeAws_json1_1TagList(output.Tags, context) : undefined,
-        Transcript: output.Transcript != null ? deserializeAws_json1_1Transcript(output.Transcript, context) : undefined,
+        Subtitles: output.Subtitles != null ? de_SubtitlesOutput(output.Subtitles, context) : undefined,
+        Tags: output.Tags != null ? de_TagList(output.Tags, context) : undefined,
+        Transcript: output.Transcript != null ? de_Transcript(output.Transcript, context) : undefined,
         TranscriptionJobName: __expectString(output.TranscriptionJobName),
         TranscriptionJobStatus: __expectString(output.TranscriptionJobStatus),
     };
 };
-const deserializeAws_json1_1TranscriptionJobSummaries = (output, context) => {
+const de_TranscriptionJobSummaries = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1TranscriptionJobSummary(entry, context);
+        return de_TranscriptionJobSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1TranscriptionJobSummary = (output, context) => {
+const de_TranscriptionJobSummary = (output, context) => {
     return {
         CompletionTime: output.CompletionTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CompletionTime)))
             : undefined,
-        ContentRedaction: output.ContentRedaction != null
-            ? deserializeAws_json1_1ContentRedaction(output.ContentRedaction, context)
-            : undefined,
+        ContentRedaction: output.ContentRedaction != null ? de_ContentRedaction(output.ContentRedaction, context) : undefined,
         CreationTime: output.CreationTime != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreationTime)))
             : undefined,
@@ -3361,25 +3291,23 @@ const deserializeAws_json1_1TranscriptionJobSummary = (output, context) => {
         IdentifyLanguage: __expectBoolean(output.IdentifyLanguage),
         IdentifyMultipleLanguages: __expectBoolean(output.IdentifyMultipleLanguages),
         LanguageCode: __expectString(output.LanguageCode),
-        LanguageCodes: output.LanguageCodes != null ? deserializeAws_json1_1LanguageCodeList(output.LanguageCodes, context) : undefined,
-        ModelSettings: output.ModelSettings != null ? deserializeAws_json1_1ModelSettings(output.ModelSettings, context) : undefined,
+        LanguageCodes: output.LanguageCodes != null ? de_LanguageCodeList(output.LanguageCodes, context) : undefined,
+        ModelSettings: output.ModelSettings != null ? de_ModelSettings(output.ModelSettings, context) : undefined,
         OutputLocationType: __expectString(output.OutputLocationType),
         StartTime: output.StartTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.StartTime))) : undefined,
         TranscriptionJobName: __expectString(output.TranscriptionJobName),
         TranscriptionJobStatus: __expectString(output.TranscriptionJobStatus),
     };
 };
-const deserializeAws_json1_1UntagResourceResponse = (output, context) => {
+const de_UntagResourceResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1UpdateCallAnalyticsCategoryResponse = (output, context) => {
+const de_UpdateCallAnalyticsCategoryResponse = (output, context) => {
     return {
-        CategoryProperties: output.CategoryProperties != null
-            ? deserializeAws_json1_1CategoryProperties(output.CategoryProperties, context)
-            : undefined,
+        CategoryProperties: output.CategoryProperties != null ? de_CategoryProperties(output.CategoryProperties, context) : undefined,
     };
 };
-const deserializeAws_json1_1UpdateMedicalVocabularyResponse = (output, context) => {
+const de_UpdateMedicalVocabularyResponse = (output, context) => {
     return {
         LanguageCode: __expectString(output.LanguageCode),
         LastModifiedTime: output.LastModifiedTime != null
@@ -3389,7 +3317,7 @@ const deserializeAws_json1_1UpdateMedicalVocabularyResponse = (output, context)
         VocabularyState: __expectString(output.VocabularyState),
     };
 };
-const deserializeAws_json1_1UpdateVocabularyFilterResponse = (output, context) => {
+const de_UpdateVocabularyFilterResponse = (output, context) => {
     return {
         LanguageCode: __expectString(output.LanguageCode),
         LastModifiedTime: output.LastModifiedTime != null
@@ -3398,7 +3326,7 @@ const deserializeAws_json1_1UpdateVocabularyFilterResponse = (output, context) =
         VocabularyFilterName: __expectString(output.VocabularyFilterName),
     };
 };
-const deserializeAws_json1_1UpdateVocabularyResponse = (output, context) => {
+const de_UpdateVocabularyResponse = (output, context) => {
     return {
         LanguageCode: __expectString(output.LanguageCode),
         LastModifiedTime: output.LastModifiedTime != null
@@ -3408,18 +3336,18 @@ const deserializeAws_json1_1UpdateVocabularyResponse = (output, context) => {
         VocabularyState: __expectString(output.VocabularyState),
     };
 };
-const deserializeAws_json1_1Vocabularies = (output, context) => {
+const de_Vocabularies = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1VocabularyInfo(entry, context);
+        return de_VocabularyInfo(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1VocabularyFilterInfo = (output, context) => {
+const de_VocabularyFilterInfo = (output, context) => {
     return {
         LanguageCode: __expectString(output.LanguageCode),
         LastModifiedTime: output.LastModifiedTime != null
@@ -3428,18 +3356,18 @@ const deserializeAws_json1_1VocabularyFilterInfo = (output, context) => {
         VocabularyFilterName: __expectString(output.VocabularyFilterName),
     };
 };
-const deserializeAws_json1_1VocabularyFilters = (output, context) => {
+const de_VocabularyFilters = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1VocabularyFilterInfo(entry, context);
+        return de_VocabularyFilterInfo(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1VocabularyInfo = (output, context) => {
+const de_VocabularyInfo = (output, context) => {
     return {
         LanguageCode: __expectString(output.LanguageCode),
         LastModifiedTime: output.LastModifiedTime != null