@aws-sdk/client-lex-runtime-v2 3.306.0 → 3.310.0

package/dist-es/protocols/Aws_restJson1.js

@@ -2,7 +2,7 @@ import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, map as __map, resolvedPath as __resolvedPath, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { LexRuntimeV2ServiceException as __BaseException } from "../models/LexRuntimeV2ServiceException";
 import { AccessDeniedException, BadGatewayException, ConflictException, DependencyFailedException, InternalServerException, ResourceNotFoundException, StartConversationRequestEventStream, ThrottlingException, ValidationException, } from "../models/models_0";
-export const serializeAws_restJson1DeleteSessionCommand = async (input, context) => {
+export const se_DeleteSessionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -22,7 +22,7 @@ export const serializeAws_restJson1DeleteSessionCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1GetSessionCommand = async (input, context) => {
+export const se_GetSessionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
@@ -42,7 +42,7 @@ export const serializeAws_restJson1GetSessionCommand = async (input, context) =>
         body,
     });
 };
-export const serializeAws_restJson1PutSessionCommand = async (input, context) => {
+export const se_PutSessionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
         "content-type": "application/json",
@@ -56,13 +56,9 @@ export const serializeAws_restJson1PutSessionCommand = async (input, context) =>
     resolvedPath = __resolvedPath(resolvedPath, input, "sessionId", () => input.sessionId, "{sessionId}", false);
     let body;
     body = JSON.stringify({
-        ...(input.messages != null && { messages: serializeAws_restJson1Messages(input.messages, context) }),
-        ...(input.requestAttributes != null && {
-            requestAttributes: serializeAws_restJson1StringMap(input.requestAttributes, context),
-        }),
-        ...(input.sessionState != null && {
-            sessionState: serializeAws_restJson1SessionState(input.sessionState, context),
-        }),
+        ...(input.messages != null && { messages: se_Messages(input.messages, context) }),
+        ...(input.requestAttributes != null && { requestAttributes: se_StringMap(input.requestAttributes, context) }),
+        ...(input.sessionState != null && { sessionState: se_SessionState(input.sessionState, context) }),
     });
     return new __HttpRequest({
         protocol,
@@ -74,7 +70,7 @@ export const serializeAws_restJson1PutSessionCommand = async (input, context) =>
         body,
     });
 };
-export const serializeAws_restJson1RecognizeTextCommand = async (input, context) => {
+export const se_RecognizeTextCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
         "content-type": "application/json",
@@ -87,12 +83,8 @@ export const serializeAws_restJson1RecognizeTextCommand = async (input, context)
     resolvedPath = __resolvedPath(resolvedPath, input, "sessionId", () => input.sessionId, "{sessionId}", false);
     let body;
     body = JSON.stringify({
-        ...(input.requestAttributes != null && {
-            requestAttributes: serializeAws_restJson1StringMap(input.requestAttributes, context),
-        }),
-        ...(input.sessionState != null && {
-            sessionState: serializeAws_restJson1SessionState(input.sessionState, context),
-        }),
+        ...(input.requestAttributes != null && { requestAttributes: se_StringMap(input.requestAttributes, context) }),
+        ...(input.sessionState != null && { sessionState: se_SessionState(input.sessionState, context) }),
         ...(input.text != null && { text: input.text }),
     });
     return new __HttpRequest({
@@ -105,7 +97,7 @@ export const serializeAws_restJson1RecognizeTextCommand = async (input, context)
         body,
     });
 };
-export const serializeAws_restJson1RecognizeUtteranceCommand = async (input, context) => {
+export const se_RecognizeUtteranceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
         "x-amz-content-sha256": "UNSIGNED-PAYLOAD",
@@ -134,7 +126,7 @@ export const serializeAws_restJson1RecognizeUtteranceCommand = async (input, con
         body,
     });
 };
-export const serializeAws_restJson1StartConversationCommand = async (input, context) => {
+export const se_StartConversationCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = map({}, isSerializableHeaderValue, {
         "x-amz-lex-conversation-mode": input.conversationMode,
@@ -147,7 +139,7 @@ export const serializeAws_restJson1StartConversationCommand = async (input, cont
     resolvedPath = __resolvedPath(resolvedPath, input, "sessionId", () => input.sessionId, "{sessionId}", false);
     let body;
     if (input.requestEventStream !== undefined) {
-        body = serializeAws_restJson1StartConversationRequestEventStream(input.requestEventStream, context);
+        body = se_StartConversationRequestEventStream(input.requestEventStream, context);
     }
     return new __HttpRequest({
         protocol,
@@ -159,9 +151,9 @@ export const serializeAws_restJson1StartConversationCommand = async (input, cont
         body,
     });
 };
-export const deserializeAws_restJson1DeleteSessionCommand = async (output, context) => {
+export const de_DeleteSessionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1DeleteSessionCommandError(output, context);
+        return de_DeleteSessionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -181,7 +173,7 @@ export const deserializeAws_restJson1DeleteSessionCommand = async (output, conte
     }
     return contents;
 };
-const deserializeAws_restJson1DeleteSessionCommandError = async (output, context) => {
+const de_DeleteSessionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -190,22 +182,22 @@ const deserializeAws_restJson1DeleteSessionCommandError = async (output, context
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.lexruntimev2#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.lexruntimev2#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.lexruntimev2#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.lexruntimev2#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.lexruntimev2#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.lexruntimev2#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -216,29 +208,29 @@ const deserializeAws_restJson1DeleteSessionCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1GetSessionCommand = async (output, context) => {
+export const de_GetSessionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1GetSessionCommandError(output, context);
+        return de_GetSessionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.interpretations != null) {
-        contents.interpretations = deserializeAws_restJson1Interpretations(data.interpretations, context);
+        contents.interpretations = de_Interpretations(data.interpretations, context);
     }
     if (data.messages != null) {
-        contents.messages = deserializeAws_restJson1Messages(data.messages, context);
+        contents.messages = de_Messages(data.messages, context);
     }
     if (data.sessionId != null) {
         contents.sessionId = __expectString(data.sessionId);
     }
     if (data.sessionState != null) {
-        contents.sessionState = deserializeAws_restJson1SessionState(data.sessionState, context);
+        contents.sessionState = de_SessionState(data.sessionState, context);
     }
     return contents;
 };
-const deserializeAws_restJson1GetSessionCommandError = async (output, context) => {
+const de_GetSessionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -247,19 +239,19 @@ const deserializeAws_restJson1GetSessionCommandError = async (output, context) =
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.lexruntimev2#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.lexruntimev2#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.lexruntimev2#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.lexruntimev2#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.lexruntimev2#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -270,9 +262,9 @@ const deserializeAws_restJson1GetSessionCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_restJson1PutSessionCommand = async (output, context) => {
+export const de_PutSessionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1PutSessionCommandError(output, context);
+        return de_PutSessionCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -287,7 +279,7 @@ export const deserializeAws_restJson1PutSessionCommand = async (output, context)
     contents.audioStream = data;
     return contents;
 };
-const deserializeAws_restJson1PutSessionCommandError = async (output, context) => {
+const de_PutSessionCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -296,28 +288,28 @@ const deserializeAws_restJson1PutSessionCommandError = async (output, context) =
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.lexruntimev2#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadGatewayException":
         case "com.amazonaws.lexruntimev2#BadGatewayException":
-            throw await deserializeAws_restJson1BadGatewayExceptionResponse(parsedOutput, context);
+            throw await de_BadGatewayExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.lexruntimev2#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "DependencyFailedException":
         case "com.amazonaws.lexruntimev2#DependencyFailedException":
-            throw await deserializeAws_restJson1DependencyFailedExceptionResponse(parsedOutput, context);
+            throw await de_DependencyFailedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.lexruntimev2#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.lexruntimev2#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.lexruntimev2#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.lexruntimev2#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -328,35 +320,35 @@ const deserializeAws_restJson1PutSessionCommandError = async (output, context) =
             });
     }
 };
-export const deserializeAws_restJson1RecognizeTextCommand = async (output, context) => {
+export const de_RecognizeTextCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1RecognizeTextCommandError(output, context);
+        return de_RecognizeTextCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     if (data.interpretations != null) {
-        contents.interpretations = deserializeAws_restJson1Interpretations(data.interpretations, context);
+        contents.interpretations = de_Interpretations(data.interpretations, context);
     }
     if (data.messages != null) {
-        contents.messages = deserializeAws_restJson1Messages(data.messages, context);
+        contents.messages = de_Messages(data.messages, context);
     }
     if (data.recognizedBotMember != null) {
-        contents.recognizedBotMember = deserializeAws_restJson1RecognizedBotMember(data.recognizedBotMember, context);
+        contents.recognizedBotMember = de_RecognizedBotMember(data.recognizedBotMember, context);
     }
     if (data.requestAttributes != null) {
-        contents.requestAttributes = deserializeAws_restJson1StringMap(data.requestAttributes, context);
+        contents.requestAttributes = de_StringMap(data.requestAttributes, context);
     }
     if (data.sessionId != null) {
         contents.sessionId = __expectString(data.sessionId);
     }
     if (data.sessionState != null) {
-        contents.sessionState = deserializeAws_restJson1SessionState(data.sessionState, context);
+        contents.sessionState = de_SessionState(data.sessionState, context);
     }
     return contents;
 };
-const deserializeAws_restJson1RecognizeTextCommandError = async (output, context) => {
+const de_RecognizeTextCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -365,28 +357,28 @@ const deserializeAws_restJson1RecognizeTextCommandError = async (output, context
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.lexruntimev2#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadGatewayException":
         case "com.amazonaws.lexruntimev2#BadGatewayException":
-            throw await deserializeAws_restJson1BadGatewayExceptionResponse(parsedOutput, context);
+            throw await de_BadGatewayExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.lexruntimev2#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "DependencyFailedException":
         case "com.amazonaws.lexruntimev2#DependencyFailedException":
-            throw await deserializeAws_restJson1DependencyFailedExceptionResponse(parsedOutput, context);
+            throw await de_DependencyFailedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.lexruntimev2#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.lexruntimev2#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.lexruntimev2#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.lexruntimev2#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -397,9 +389,9 @@ const deserializeAws_restJson1RecognizeTextCommandError = async (output, context
             });
     }
 };
-export const deserializeAws_restJson1RecognizeUtteranceCommand = async (output, context) => {
+export const de_RecognizeUtteranceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1RecognizeUtteranceCommandError(output, context);
+        return de_RecognizeUtteranceCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
@@ -418,7 +410,7 @@ export const deserializeAws_restJson1RecognizeUtteranceCommand = async (output,
     contents.audioStream = data;
     return contents;
 };
-const deserializeAws_restJson1RecognizeUtteranceCommandError = async (output, context) => {
+const de_RecognizeUtteranceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -427,28 +419,28 @@ const deserializeAws_restJson1RecognizeUtteranceCommandError = async (output, co
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.lexruntimev2#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "BadGatewayException":
         case "com.amazonaws.lexruntimev2#BadGatewayException":
-            throw await deserializeAws_restJson1BadGatewayExceptionResponse(parsedOutput, context);
+            throw await de_BadGatewayExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.lexruntimev2#ConflictException":
-            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "DependencyFailedException":
         case "com.amazonaws.lexruntimev2#DependencyFailedException":
-            throw await deserializeAws_restJson1DependencyFailedExceptionResponse(parsedOutput, context);
+            throw await de_DependencyFailedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.lexruntimev2#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.lexruntimev2#ResourceNotFoundException":
-            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.lexruntimev2#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.lexruntimev2#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -459,18 +451,18 @@ const deserializeAws_restJson1RecognizeUtteranceCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_restJson1StartConversationCommand = async (output, context) => {
+export const de_StartConversationCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return deserializeAws_restJson1StartConversationCommandError(output, context);
+        return de_StartConversationCommandError(output, context);
     }
     const contents = map({
         $metadata: deserializeMetadata(output),
     });
     const data = output.body;
-    contents.responseEventStream = deserializeAws_restJson1StartConversationResponseEventStream(data, context);
+    contents.responseEventStream = de_StartConversationResponseEventStream(data, context);
     return contents;
 };
-const deserializeAws_restJson1StartConversationCommandError = async (output, context) => {
+const de_StartConversationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -479,16 +471,16 @@ const deserializeAws_restJson1StartConversationCommandError = async (output, con
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.lexruntimev2#AccessDeniedException":
-            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.lexruntimev2#InternalServerException":
-            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.lexruntimev2#ThrottlingException":
-            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.lexruntimev2#ValidationException":
-            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -500,7 +492,7 @@ const deserializeAws_restJson1StartConversationCommandError = async (output, con
     }
 };
 const map = __map;
-const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -512,7 +504,7 @@ const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutpu
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1BadGatewayExceptionResponse = async (parsedOutput, context) => {
+const de_BadGatewayExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -524,7 +516,7 @@ const deserializeAws_restJson1BadGatewayExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
+const de_ConflictExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -536,7 +528,7 @@ const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, c
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1DependencyFailedExceptionResponse = async (parsedOutput, context) => {
+const de_DependencyFailedExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -548,7 +540,7 @@ const deserializeAws_restJson1DependencyFailedExceptionResponse = async (parsedO
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOutput, context) => {
+const de_InternalServerExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -560,7 +552,7 @@ const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOut
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -572,7 +564,7 @@ const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedO
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput, context) => {
+const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -584,7 +576,7 @@ const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput, context) => {
+const de_ValidationExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
     if (data.message != null) {
@@ -596,263 +588,261 @@ const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
-const serializeAws_restJson1StartConversationRequestEventStream = (input, context) => {
+const se_StartConversationRequestEventStream = (input, context) => {
     const eventMarshallingVisitor = (event) => StartConversationRequestEventStream.visit(event, {
-        ConfigurationEvent: (value) => serializeAws_restJson1ConfigurationEvent_event(value, context),
-        AudioInputEvent: (value) => serializeAws_restJson1AudioInputEvent_event(value, context),
-        DTMFInputEvent: (value) => serializeAws_restJson1DTMFInputEvent_event(value, context),
-        TextInputEvent: (value) => serializeAws_restJson1TextInputEvent_event(value, context),
-        PlaybackCompletionEvent: (value) => serializeAws_restJson1PlaybackCompletionEvent_event(value, context),
-        DisconnectionEvent: (value) => serializeAws_restJson1DisconnectionEvent_event(value, context),
+        ConfigurationEvent: (value) => se_ConfigurationEvent_event(value, context),
+        AudioInputEvent: (value) => se_AudioInputEvent_event(value, context),
+        DTMFInputEvent: (value) => se_DTMFInputEvent_event(value, context),
+        TextInputEvent: (value) => se_TextInputEvent_event(value, context),
+        PlaybackCompletionEvent: (value) => se_PlaybackCompletionEvent_event(value, context),
+        DisconnectionEvent: (value) => se_DisconnectionEvent_event(value, context),
         _: (value) => value,
     });
     return context.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
 };
-const serializeAws_restJson1AudioInputEvent_event = (input, context) => {
+const se_AudioInputEvent_event = (input, context) => {
     const headers = {
         ":event-type": { type: "string", value: "AudioInputEvent" },
         ":message-type": { type: "string", value: "event" },
         ":content-type": { type: "string", value: "application/json" },
     };
     let body = new Uint8Array();
-    body = serializeAws_restJson1AudioInputEvent(input, context);
+    body = se_AudioInputEvent(input, context);
     body = context.utf8Decoder(JSON.stringify(body));
     return { headers, body };
 };
-const serializeAws_restJson1ConfigurationEvent_event = (input, context) => {
+const se_ConfigurationEvent_event = (input, context) => {
     const headers = {
         ":event-type": { type: "string", value: "ConfigurationEvent" },
         ":message-type": { type: "string", value: "event" },
         ":content-type": { type: "string", value: "application/json" },
     };
     let body = new Uint8Array();
-    body = serializeAws_restJson1ConfigurationEvent(input, context);
+    body = se_ConfigurationEvent(input, context);
     body = context.utf8Decoder(JSON.stringify(body));
     return { headers, body };
 };
-const serializeAws_restJson1DisconnectionEvent_event = (input, context) => {
+const se_DisconnectionEvent_event = (input, context) => {
     const headers = {
         ":event-type": { type: "string", value: "DisconnectionEvent" },
         ":message-type": { type: "string", value: "event" },
         ":content-type": { type: "string", value: "application/json" },
     };
     let body = new Uint8Array();
-    body = serializeAws_restJson1DisconnectionEvent(input, context);
+    body = se_DisconnectionEvent(input, context);
     body = context.utf8Decoder(JSON.stringify(body));
     return { headers, body };
 };
-const serializeAws_restJson1DTMFInputEvent_event = (input, context) => {
+const se_DTMFInputEvent_event = (input, context) => {
     const headers = {
         ":event-type": { type: "string", value: "DTMFInputEvent" },
         ":message-type": { type: "string", value: "event" },
         ":content-type": { type: "string", value: "application/json" },
     };
     let body = new Uint8Array();
-    body = serializeAws_restJson1DTMFInputEvent(input, context);
+    body = se_DTMFInputEvent(input, context);
     body = context.utf8Decoder(JSON.stringify(body));
     return { headers, body };
 };
-const serializeAws_restJson1PlaybackCompletionEvent_event = (input, context) => {
+const se_PlaybackCompletionEvent_event = (input, context) => {
     const headers = {
         ":event-type": { type: "string", value: "PlaybackCompletionEvent" },
         ":message-type": { type: "string", value: "event" },
         ":content-type": { type: "string", value: "application/json" },
     };
     let body = new Uint8Array();
-    body = serializeAws_restJson1PlaybackCompletionEvent(input, context);
+    body = se_PlaybackCompletionEvent(input, context);
     body = context.utf8Decoder(JSON.stringify(body));
     return { headers, body };
 };
-const serializeAws_restJson1TextInputEvent_event = (input, context) => {
+const se_TextInputEvent_event = (input, context) => {
     const headers = {
         ":event-type": { type: "string", value: "TextInputEvent" },
         ":message-type": { type: "string", value: "event" },
         ":content-type": { type: "string", value: "application/json" },
     };
     let body = new Uint8Array();
-    body = serializeAws_restJson1TextInputEvent(input, context);
+    body = se_TextInputEvent(input, context);
     body = context.utf8Decoder(JSON.stringify(body));
     return { headers, body };
 };
-const deserializeAws_restJson1StartConversationResponseEventStream = (output, context) => {
+const de_StartConversationResponseEventStream = (output, context) => {
     return context.eventStreamMarshaller.deserialize(output, async (event) => {
         if (event["PlaybackInterruptionEvent"] != null) {
             return {
-                PlaybackInterruptionEvent: await deserializeAws_restJson1PlaybackInterruptionEvent_event(event["PlaybackInterruptionEvent"], context),
+                PlaybackInterruptionEvent: await de_PlaybackInterruptionEvent_event(event["PlaybackInterruptionEvent"], context),
             };
         }
         if (event["TranscriptEvent"] != null) {
             return {
-                TranscriptEvent: await deserializeAws_restJson1TranscriptEvent_event(event["TranscriptEvent"], context),
+                TranscriptEvent: await de_TranscriptEvent_event(event["TranscriptEvent"], context),
             };
         }
         if (event["IntentResultEvent"] != null) {
             return {
-                IntentResultEvent: await deserializeAws_restJson1IntentResultEvent_event(event["IntentResultEvent"], context),
+                IntentResultEvent: await de_IntentResultEvent_event(event["IntentResultEvent"], context),
             };
         }
         if (event["TextResponseEvent"] != null) {
             return {
-                TextResponseEvent: await deserializeAws_restJson1TextResponseEvent_event(event["TextResponseEvent"], context),
+                TextResponseEvent: await de_TextResponseEvent_event(event["TextResponseEvent"], context),
             };
         }
         if (event["AudioResponseEvent"] != null) {
             return {
-                AudioResponseEvent: await deserializeAws_restJson1AudioResponseEvent_event(event["AudioResponseEvent"], context),
+                AudioResponseEvent: await de_AudioResponseEvent_event(event["AudioResponseEvent"], context),
             };
         }
         if (event["HeartbeatEvent"] != null) {
             return {
-                HeartbeatEvent: await deserializeAws_restJson1HeartbeatEvent_event(event["HeartbeatEvent"], context),
+                HeartbeatEvent: await de_HeartbeatEvent_event(event["HeartbeatEvent"], context),
             };
         }
         if (event["AccessDeniedException"] != null) {
             return {
-                AccessDeniedException: await deserializeAws_restJson1AccessDeniedException_event(event["AccessDeniedException"], context),
+                AccessDeniedException: await de_AccessDeniedException_event(event["AccessDeniedException"], context),
             };
         }
         if (event["ResourceNotFoundException"] != null) {
             return {
-                ResourceNotFoundException: await deserializeAws_restJson1ResourceNotFoundException_event(event["ResourceNotFoundException"], context),
+                ResourceNotFoundException: await de_ResourceNotFoundException_event(event["ResourceNotFoundException"], context),
             };
         }
         if (event["ValidationException"] != null) {
             return {
-                ValidationException: await deserializeAws_restJson1ValidationException_event(event["ValidationException"], context),
+                ValidationException: await de_ValidationException_event(event["ValidationException"], context),
             };
         }
         if (event["ThrottlingException"] != null) {
             return {
-                ThrottlingException: await deserializeAws_restJson1ThrottlingException_event(event["ThrottlingException"], context),
+                ThrottlingException: await de_ThrottlingException_event(event["ThrottlingException"], context),
             };
         }
         if (event["InternalServerException"] != null) {
             return {
-                InternalServerException: await deserializeAws_restJson1InternalServerException_event(event["InternalServerException"], context),
+                InternalServerException: await de_InternalServerException_event(event["InternalServerException"], context),
             };
         }
         if (event["ConflictException"] != null) {
             return {
-                ConflictException: await deserializeAws_restJson1ConflictException_event(event["ConflictException"], context),
+                ConflictException: await de_ConflictException_event(event["ConflictException"], context),
             };
         }
         if (event["DependencyFailedException"] != null) {
             return {
-                DependencyFailedException: await deserializeAws_restJson1DependencyFailedException_event(event["DependencyFailedException"], context),
+                DependencyFailedException: await de_DependencyFailedException_event(event["DependencyFailedException"], context),
             };
         }
         if (event["BadGatewayException"] != null) {
             return {
-                BadGatewayException: await deserializeAws_restJson1BadGatewayException_event(event["BadGatewayException"], context),
+                BadGatewayException: await de_BadGatewayException_event(event["BadGatewayException"], context),
             };
         }
         return { $unknown: output };
     });
 };
-const deserializeAws_restJson1AccessDeniedException_event = async (output, context) => {
+const de_AccessDeniedException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
     };
-    return deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+    return de_AccessDeniedExceptionRes(parsedOutput, context);
 };
-const deserializeAws_restJson1AudioResponseEvent_event = async (output, context) => {
+const de_AudioResponseEvent_event = async (output, context) => {
     const contents = {};
     const data = await parseBody(output.body, context);
-    Object.assign(contents, deserializeAws_restJson1AudioResponseEvent(data, context));
+    Object.assign(contents, de_AudioResponseEvent(data, context));
     return contents;
 };
-const deserializeAws_restJson1BadGatewayException_event = async (output, context) => {
+const de_BadGatewayException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
     };
-    return deserializeAws_restJson1BadGatewayExceptionResponse(parsedOutput, context);
+    return de_BadGatewayExceptionRes(parsedOutput, context);
 };
-const deserializeAws_restJson1ConflictException_event = async (output, context) => {
+const de_ConflictException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
     };
-    return deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+    return de_ConflictExceptionRes(parsedOutput, context);
 };
-const deserializeAws_restJson1DependencyFailedException_event = async (output, context) => {
+const de_DependencyFailedException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
     };
-    return deserializeAws_restJson1DependencyFailedExceptionResponse(parsedOutput, context);
+    return de_DependencyFailedExceptionRes(parsedOutput, context);
 };
-const deserializeAws_restJson1HeartbeatEvent_event = async (output, context) => {
+const de_HeartbeatEvent_event = async (output, context) => {
     const contents = {};
     const data = await parseBody(output.body, context);
-    Object.assign(contents, deserializeAws_restJson1HeartbeatEvent(data, context));
+    Object.assign(contents, de_HeartbeatEvent(data, context));
     return contents;
 };
-const deserializeAws_restJson1IntentResultEvent_event = async (output, context) => {
+const de_IntentResultEvent_event = async (output, context) => {
     const contents = {};
     const data = await parseBody(output.body, context);
-    Object.assign(contents, deserializeAws_restJson1IntentResultEvent(data, context));
+    Object.assign(contents, de_IntentResultEvent(data, context));
     return contents;
 };
-const deserializeAws_restJson1InternalServerException_event = async (output, context) => {
+const de_InternalServerException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
     };
-    return deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+    return de_InternalServerExceptionRes(parsedOutput, context);
 };
-const deserializeAws_restJson1PlaybackInterruptionEvent_event = async (output, context) => {
+const de_PlaybackInterruptionEvent_event = async (output, context) => {
     const contents = {};
     const data = await parseBody(output.body, context);
-    Object.assign(contents, deserializeAws_restJson1PlaybackInterruptionEvent(data, context));
+    Object.assign(contents, de_PlaybackInterruptionEvent(data, context));
     return contents;
 };
-const deserializeAws_restJson1ResourceNotFoundException_event = async (output, context) => {
+const de_ResourceNotFoundException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
     };
-    return deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+    return de_ResourceNotFoundExceptionRes(parsedOutput, context);
 };
-const deserializeAws_restJson1TextResponseEvent_event = async (output, context) => {
+const de_TextResponseEvent_event = async (output, context) => {
     const contents = {};
     const data = await parseBody(output.body, context);
-    Object.assign(contents, deserializeAws_restJson1TextResponseEvent(data, context));
+    Object.assign(contents, de_TextResponseEvent(data, context));
     return contents;
 };
-const deserializeAws_restJson1ThrottlingException_event = async (output, context) => {
+const de_ThrottlingException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
     };
-    return deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+    return de_ThrottlingExceptionRes(parsedOutput, context);
 };
-const deserializeAws_restJson1TranscriptEvent_event = async (output, context) => {
+const de_TranscriptEvent_event = async (output, context) => {
     const contents = {};
     const data = await parseBody(output.body, context);
-    Object.assign(contents, deserializeAws_restJson1TranscriptEvent(data, context));
+    Object.assign(contents, de_TranscriptEvent(data, context));
     return contents;
 };
-const deserializeAws_restJson1ValidationException_event = async (output, context) => {
+const de_ValidationException_event = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseBody(output.body, context),
     };
-    return deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+    return de_ValidationExceptionRes(parsedOutput, context);
 };
-const serializeAws_restJson1ActiveContext = (input, context) => {
+const se_ActiveContext = (input, context) => {
     return {
         ...(input.contextAttributes != null && {
-            contextAttributes: serializeAws_restJson1ActiveContextParametersMap(input.contextAttributes, context),
+            contextAttributes: se_ActiveContextParametersMap(input.contextAttributes, context),
         }),
         ...(input.name != null && { name: input.name }),
-        ...(input.timeToLive != null && {
-            timeToLive: serializeAws_restJson1ActiveContextTimeToLive(input.timeToLive, context),
-        }),
+        ...(input.timeToLive != null && { timeToLive: se_ActiveContextTimeToLive(input.timeToLive, context) }),
     };
 };
-const serializeAws_restJson1ActiveContextParametersMap = (input, context) => {
+const se_ActiveContextParametersMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -861,20 +851,20 @@ const serializeAws_restJson1ActiveContextParametersMap = (input, context) => {
         return acc;
     }, {});
 };
-const serializeAws_restJson1ActiveContextsList = (input, context) => {
+const se_ActiveContextsList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1ActiveContext(entry, context);
+        return se_ActiveContext(entry, context);
     });
 };
-const serializeAws_restJson1ActiveContextTimeToLive = (input, context) => {
+const se_ActiveContextTimeToLive = (input, context) => {
     return {
         ...(input.timeToLiveInSeconds != null && { timeToLiveInSeconds: input.timeToLiveInSeconds }),
         ...(input.turnsToLive != null && { turnsToLive: input.turnsToLive }),
     };
 };
-const serializeAws_restJson1AudioInputEvent = (input, context) => {
+const se_AudioInputEvent = (input, context) => {
     return {
         ...(input.audioChunk != null && { audioChunk: context.base64Encoder(input.audioChunk) }),
         ...(input.clientTimestampMillis != null && { clientTimestampMillis: input.clientTimestampMillis }),
@@ -882,193 +872,173 @@ const serializeAws_restJson1AudioInputEvent = (input, context) => {
         ...(input.eventId != null && { eventId: input.eventId }),
     };
 };
-const serializeAws_restJson1Button = (input, context) => {
+const se_Button = (input, context) => {
     return {
         ...(input.text != null && { text: input.text }),
         ...(input.value != null && { value: input.value }),
     };
 };
-const serializeAws_restJson1ButtonsList = (input, context) => {
+const se_ButtonsList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1Button(entry, context);
+        return se_Button(entry, context);
     });
 };
-const serializeAws_restJson1ConfigurationEvent = (input, context) => {
+const se_ConfigurationEvent = (input, context) => {
     return {
         ...(input.clientTimestampMillis != null && { clientTimestampMillis: input.clientTimestampMillis }),
         ...(input.disablePlayback != null && { disablePlayback: input.disablePlayback }),
         ...(input.eventId != null && { eventId: input.eventId }),
-        ...(input.requestAttributes != null && {
-            requestAttributes: serializeAws_restJson1StringMap(input.requestAttributes, context),
-        }),
+        ...(input.requestAttributes != null && { requestAttributes: se_StringMap(input.requestAttributes, context) }),
         ...(input.responseContentType != null && { responseContentType: input.responseContentType }),
-        ...(input.sessionState != null && {
-            sessionState: serializeAws_restJson1SessionState(input.sessionState, context),
-        }),
-        ...(input.welcomeMessages != null && {
-            welcomeMessages: serializeAws_restJson1Messages(input.welcomeMessages, context),
-        }),
+        ...(input.sessionState != null && { sessionState: se_SessionState(input.sessionState, context) }),
+        ...(input.welcomeMessages != null && { welcomeMessages: se_Messages(input.welcomeMessages, context) }),
     };
 };
-const serializeAws_restJson1DialogAction = (input, context) => {
+const se_DialogAction = (input, context) => {
     return {
         ...(input.slotElicitationStyle != null && { slotElicitationStyle: input.slotElicitationStyle }),
         ...(input.slotToElicit != null && { slotToElicit: input.slotToElicit }),
-        ...(input.subSlotToElicit != null && {
-            subSlotToElicit: serializeAws_restJson1ElicitSubSlot(input.subSlotToElicit, context),
-        }),
+        ...(input.subSlotToElicit != null && { subSlotToElicit: se_ElicitSubSlot(input.subSlotToElicit, context) }),
         ...(input.type != null && { type: input.type }),
     };
 };
-const serializeAws_restJson1DisconnectionEvent = (input, context) => {
+const se_DisconnectionEvent = (input, context) => {
     return {
         ...(input.clientTimestampMillis != null && { clientTimestampMillis: input.clientTimestampMillis }),
         ...(input.eventId != null && { eventId: input.eventId }),
     };
 };
-const serializeAws_restJson1DTMFInputEvent = (input, context) => {
+const se_DTMFInputEvent = (input, context) => {
     return {
         ...(input.clientTimestampMillis != null && { clientTimestampMillis: input.clientTimestampMillis }),
         ...(input.eventId != null && { eventId: input.eventId }),
         ...(input.inputCharacter != null && { inputCharacter: input.inputCharacter }),
     };
 };
-const serializeAws_restJson1ElicitSubSlot = (input, context) => {
+const se_ElicitSubSlot = (input, context) => {
     return {
         ...(input.name != null && { name: input.name }),
-        ...(input.subSlotToElicit != null && {
-            subSlotToElicit: serializeAws_restJson1ElicitSubSlot(input.subSlotToElicit, context),
-        }),
+        ...(input.subSlotToElicit != null && { subSlotToElicit: se_ElicitSubSlot(input.subSlotToElicit, context) }),
     };
 };
-const serializeAws_restJson1ImageResponseCard = (input, context) => {
+const se_ImageResponseCard = (input, context) => {
     return {
-        ...(input.buttons != null && { buttons: serializeAws_restJson1ButtonsList(input.buttons, context) }),
+        ...(input.buttons != null && { buttons: se_ButtonsList(input.buttons, context) }),
         ...(input.imageUrl != null && { imageUrl: input.imageUrl }),
         ...(input.subtitle != null && { subtitle: input.subtitle }),
         ...(input.title != null && { title: input.title }),
     };
 };
-const serializeAws_restJson1Intent = (input, context) => {
+const se_Intent = (input, context) => {
     return {
         ...(input.confirmationState != null && { confirmationState: input.confirmationState }),
         ...(input.name != null && { name: input.name }),
-        ...(input.slots != null && { slots: serializeAws_restJson1Slots(input.slots, context) }),
+        ...(input.slots != null && { slots: se_Slots(input.slots, context) }),
         ...(input.state != null && { state: input.state }),
     };
 };
-const serializeAws_restJson1Message = (input, context) => {
+const se_Message = (input, context) => {
     return {
         ...(input.content != null && { content: input.content }),
         ...(input.contentType != null && { contentType: input.contentType }),
         ...(input.imageResponseCard != null && {
-            imageResponseCard: serializeAws_restJson1ImageResponseCard(input.imageResponseCard, context),
+            imageResponseCard: se_ImageResponseCard(input.imageResponseCard, context),
         }),
     };
 };
-const serializeAws_restJson1Messages = (input, context) => {
+const se_Messages = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1Message(entry, context);
+        return se_Message(entry, context);
     });
 };
-const serializeAws_restJson1PlaybackCompletionEvent = (input, context) => {
+const se_PlaybackCompletionEvent = (input, context) => {
     return {
         ...(input.clientTimestampMillis != null && { clientTimestampMillis: input.clientTimestampMillis }),
         ...(input.eventId != null && { eventId: input.eventId }),
     };
 };
-const serializeAws_restJson1RuntimeHintDetails = (input, context) => {
+const se_RuntimeHintDetails = (input, context) => {
     return {
         ...(input.runtimeHintValues != null && {
-            runtimeHintValues: serializeAws_restJson1RuntimeHintValuesList(input.runtimeHintValues, context),
-        }),
-        ...(input.subSlotHints != null && {
-            subSlotHints: serializeAws_restJson1SlotHintsSlotMap(input.subSlotHints, context),
+            runtimeHintValues: se_RuntimeHintValuesList(input.runtimeHintValues, context),
         }),
+        ...(input.subSlotHints != null && { subSlotHints: se_SlotHintsSlotMap(input.subSlotHints, context) }),
     };
 };
-const serializeAws_restJson1RuntimeHints = (input, context) => {
+const se_RuntimeHints = (input, context) => {
     return {
-        ...(input.slotHints != null && { slotHints: serializeAws_restJson1SlotHintsIntentMap(input.slotHints, context) }),
+        ...(input.slotHints != null && { slotHints: se_SlotHintsIntentMap(input.slotHints, context) }),
     };
 };
-const serializeAws_restJson1RuntimeHintValue = (input, context) => {
+const se_RuntimeHintValue = (input, context) => {
     return {
         ...(input.phrase != null && { phrase: input.phrase }),
     };
 };
-const serializeAws_restJson1RuntimeHintValuesList = (input, context) => {
+const se_RuntimeHintValuesList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1RuntimeHintValue(entry, context);
+        return se_RuntimeHintValue(entry, context);
     });
 };
-const serializeAws_restJson1SessionState = (input, context) => {
+const se_SessionState = (input, context) => {
     return {
-        ...(input.activeContexts != null && {
-            activeContexts: serializeAws_restJson1ActiveContextsList(input.activeContexts, context),
-        }),
-        ...(input.dialogAction != null && {
-            dialogAction: serializeAws_restJson1DialogAction(input.dialogAction, context),
-        }),
-        ...(input.intent != null && { intent: serializeAws_restJson1Intent(input.intent, context) }),
+        ...(input.activeContexts != null && { activeContexts: se_ActiveContextsList(input.activeContexts, context) }),
+        ...(input.dialogAction != null && { dialogAction: se_DialogAction(input.dialogAction, context) }),
+        ...(input.intent != null && { intent: se_Intent(input.intent, context) }),
         ...(input.originatingRequestId != null && { originatingRequestId: input.originatingRequestId }),
-        ...(input.runtimeHints != null && {
-            runtimeHints: serializeAws_restJson1RuntimeHints(input.runtimeHints, context),
-        }),
-        ...(input.sessionAttributes != null && {
-            sessionAttributes: serializeAws_restJson1StringMap(input.sessionAttributes, context),
-        }),
+        ...(input.runtimeHints != null && { runtimeHints: se_RuntimeHints(input.runtimeHints, context) }),
+        ...(input.sessionAttributes != null && { sessionAttributes: se_StringMap(input.sessionAttributes, context) }),
     };
 };
-const serializeAws_restJson1Slot = (input, context) => {
+const se_Slot = (input, context) => {
     return {
         ...(input.shape != null && { shape: input.shape }),
-        ...(input.subSlots != null && { subSlots: serializeAws_restJson1Slots(input.subSlots, context) }),
-        ...(input.value != null && { value: serializeAws_restJson1Value(input.value, context) }),
-        ...(input.values != null && { values: serializeAws_restJson1Values(input.values, context) }),
+        ...(input.subSlots != null && { subSlots: se_Slots(input.subSlots, context) }),
+        ...(input.value != null && { value: se_Value(input.value, context) }),
+        ...(input.values != null && { values: se_Values(input.values, context) }),
     };
 };
-const serializeAws_restJson1SlotHintsIntentMap = (input, context) => {
+const se_SlotHintsIntentMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = serializeAws_restJson1SlotHintsSlotMap(value, context);
+        acc[key] = se_SlotHintsSlotMap(value, context);
         return acc;
     }, {});
 };
-const serializeAws_restJson1SlotHintsSlotMap = (input, context) => {
+const se_SlotHintsSlotMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = serializeAws_restJson1RuntimeHintDetails(value, context);
+        acc[key] = se_RuntimeHintDetails(value, context);
         return acc;
     }, {});
 };
-const serializeAws_restJson1Slots = (input, context) => {
+const se_Slots = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = serializeAws_restJson1Slot(value, context);
+        acc[key] = se_Slot(value, context);
         return acc;
     }, {});
 };
-const serializeAws_restJson1StringList = (input, context) => {
+const se_StringList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_restJson1StringMap = (input, context) => {
+const se_StringMap = (input, context) => {
     return Object.entries(input).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -1077,41 +1047,35 @@ const serializeAws_restJson1StringMap = (input, context) => {
         return acc;
     }, {});
 };
-const serializeAws_restJson1TextInputEvent = (input, context) => {
+const se_TextInputEvent = (input, context) => {
     return {
         ...(input.clientTimestampMillis != null && { clientTimestampMillis: input.clientTimestampMillis }),
         ...(input.eventId != null && { eventId: input.eventId }),
         ...(input.text != null && { text: input.text }),
     };
 };
-const serializeAws_restJson1Value = (input, context) => {
+const se_Value = (input, context) => {
     return {
         ...(input.interpretedValue != null && { interpretedValue: input.interpretedValue }),
         ...(input.originalValue != null && { originalValue: input.originalValue }),
-        ...(input.resolvedValues != null && {
-            resolvedValues: serializeAws_restJson1StringList(input.resolvedValues, context),
-        }),
+        ...(input.resolvedValues != null && { resolvedValues: se_StringList(input.resolvedValues, context) }),
     };
 };
-const serializeAws_restJson1Values = (input, context) => {
+const se_Values = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_restJson1Slot(entry, context);
+        return se_Slot(entry, context);
     });
 };
-const deserializeAws_restJson1ActiveContext = (output, context) => {
+const de_ActiveContext = (output, context) => {
     return {
-        contextAttributes: output.contextAttributes != null
-            ? deserializeAws_restJson1ActiveContextParametersMap(output.contextAttributes, context)
-            : undefined,
+        contextAttributes: output.contextAttributes != null ? de_ActiveContextParametersMap(output.contextAttributes, context) : undefined,
         name: __expectString(output.name),
-        timeToLive: output.timeToLive != null
-            ? deserializeAws_restJson1ActiveContextTimeToLive(output.timeToLive, context)
-            : undefined,
+        timeToLive: output.timeToLive != null ? de_ActiveContextTimeToLive(output.timeToLive, context) : undefined,
     };
 };
-const deserializeAws_restJson1ActiveContextParametersMap = (output, context) => {
+const de_ActiveContextParametersMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -1120,199 +1084,181 @@ const deserializeAws_restJson1ActiveContextParametersMap = (output, context) =>
         return acc;
     }, {});
 };
-const deserializeAws_restJson1ActiveContextsList = (output, context) => {
+const de_ActiveContextsList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1ActiveContext(entry, context);
+        return de_ActiveContext(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ActiveContextTimeToLive = (output, context) => {
+const de_ActiveContextTimeToLive = (output, context) => {
     return {
         timeToLiveInSeconds: __expectInt32(output.timeToLiveInSeconds),
         turnsToLive: __expectInt32(output.turnsToLive),
     };
 };
-const deserializeAws_restJson1AudioResponseEvent = (output, context) => {
+const de_AudioResponseEvent = (output, context) => {
     return {
         audioChunk: output.audioChunk != null ? context.base64Decoder(output.audioChunk) : undefined,
         contentType: __expectString(output.contentType),
         eventId: __expectString(output.eventId),
     };
 };
-const deserializeAws_restJson1Button = (output, context) => {
+const de_Button = (output, context) => {
     return {
         text: __expectString(output.text),
         value: __expectString(output.value),
     };
 };
-const deserializeAws_restJson1ButtonsList = (output, context) => {
+const de_ButtonsList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Button(entry, context);
+        return de_Button(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1ConfidenceScore = (output, context) => {
+const de_ConfidenceScore = (output, context) => {
     return {
         score: __limitedParseDouble(output.score),
     };
 };
-const deserializeAws_restJson1DialogAction = (output, context) => {
+const de_DialogAction = (output, context) => {
     return {
         slotElicitationStyle: __expectString(output.slotElicitationStyle),
         slotToElicit: __expectString(output.slotToElicit),
-        subSlotToElicit: output.subSlotToElicit != null
-            ? deserializeAws_restJson1ElicitSubSlot(output.subSlotToElicit, context)
-            : undefined,
+        subSlotToElicit: output.subSlotToElicit != null ? de_ElicitSubSlot(output.subSlotToElicit, context) : undefined,
         type: __expectString(output.type),
     };
 };
-const deserializeAws_restJson1ElicitSubSlot = (output, context) => {
+const de_ElicitSubSlot = (output, context) => {
     return {
         name: __expectString(output.name),
-        subSlotToElicit: output.subSlotToElicit != null
-            ? deserializeAws_restJson1ElicitSubSlot(output.subSlotToElicit, context)
-            : undefined,
+        subSlotToElicit: output.subSlotToElicit != null ? de_ElicitSubSlot(output.subSlotToElicit, context) : undefined,
     };
 };
-const deserializeAws_restJson1HeartbeatEvent = (output, context) => {
+const de_HeartbeatEvent = (output, context) => {
     return {
         eventId: __expectString(output.eventId),
     };
 };
-const deserializeAws_restJson1ImageResponseCard = (output, context) => {
+const de_ImageResponseCard = (output, context) => {
     return {
-        buttons: output.buttons != null ? deserializeAws_restJson1ButtonsList(output.buttons, context) : undefined,
+        buttons: output.buttons != null ? de_ButtonsList(output.buttons, context) : undefined,
         imageUrl: __expectString(output.imageUrl),
         subtitle: __expectString(output.subtitle),
         title: __expectString(output.title),
     };
 };
-const deserializeAws_restJson1Intent = (output, context) => {
+const de_Intent = (output, context) => {
     return {
         confirmationState: __expectString(output.confirmationState),
         name: __expectString(output.name),
-        slots: output.slots != null ? deserializeAws_restJson1Slots(output.slots, context) : undefined,
+        slots: output.slots != null ? de_Slots(output.slots, context) : undefined,
         state: __expectString(output.state),
     };
 };
-const deserializeAws_restJson1IntentResultEvent = (output, context) => {
+const de_IntentResultEvent = (output, context) => {
     return {
         eventId: __expectString(output.eventId),
         inputMode: __expectString(output.inputMode),
-        interpretations: output.interpretations != null
-            ? deserializeAws_restJson1Interpretations(output.interpretations, context)
-            : undefined,
-        recognizedBotMember: output.recognizedBotMember != null
-            ? deserializeAws_restJson1RecognizedBotMember(output.recognizedBotMember, context)
-            : undefined,
-        requestAttributes: output.requestAttributes != null
-            ? deserializeAws_restJson1StringMap(output.requestAttributes, context)
-            : undefined,
+        interpretations: output.interpretations != null ? de_Interpretations(output.interpretations, context) : undefined,
+        recognizedBotMember: output.recognizedBotMember != null ? de_RecognizedBotMember(output.recognizedBotMember, context) : undefined,
+        requestAttributes: output.requestAttributes != null ? de_StringMap(output.requestAttributes, context) : undefined,
         sessionId: __expectString(output.sessionId),
-        sessionState: output.sessionState != null ? deserializeAws_restJson1SessionState(output.sessionState, context) : undefined,
+        sessionState: output.sessionState != null ? de_SessionState(output.sessionState, context) : undefined,
     };
 };
-const deserializeAws_restJson1Interpretation = (output, context) => {
+const de_Interpretation = (output, context) => {
     return {
-        intent: output.intent != null ? deserializeAws_restJson1Intent(output.intent, context) : undefined,
-        nluConfidence: output.nluConfidence != null ? deserializeAws_restJson1ConfidenceScore(output.nluConfidence, context) : undefined,
-        sentimentResponse: output.sentimentResponse != null
-            ? deserializeAws_restJson1SentimentResponse(output.sentimentResponse, context)
-            : undefined,
+        intent: output.intent != null ? de_Intent(output.intent, context) : undefined,
+        nluConfidence: output.nluConfidence != null ? de_ConfidenceScore(output.nluConfidence, context) : undefined,
+        sentimentResponse: output.sentimentResponse != null ? de_SentimentResponse(output.sentimentResponse, context) : undefined,
     };
 };
-const deserializeAws_restJson1Interpretations = (output, context) => {
+const de_Interpretations = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Interpretation(entry, context);
+        return de_Interpretation(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1Message = (output, context) => {
+const de_Message = (output, context) => {
     return {
         content: __expectString(output.content),
         contentType: __expectString(output.contentType),
-        imageResponseCard: output.imageResponseCard != null
-            ? deserializeAws_restJson1ImageResponseCard(output.imageResponseCard, context)
-            : undefined,
+        imageResponseCard: output.imageResponseCard != null ? de_ImageResponseCard(output.imageResponseCard, context) : undefined,
     };
 };
-const deserializeAws_restJson1Messages = (output, context) => {
+const de_Messages = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Message(entry, context);
+        return de_Message(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1PlaybackInterruptionEvent = (output, context) => {
+const de_PlaybackInterruptionEvent = (output, context) => {
     return {
         causedByEventId: __expectString(output.causedByEventId),
         eventId: __expectString(output.eventId),
         eventReason: __expectString(output.eventReason),
     };
 };
-const deserializeAws_restJson1RecognizedBotMember = (output, context) => {
+const de_RecognizedBotMember = (output, context) => {
     return {
         botId: __expectString(output.botId),
         botName: __expectString(output.botName),
     };
 };
-const deserializeAws_restJson1RuntimeHintDetails = (output, context) => {
+const de_RuntimeHintDetails = (output, context) => {
     return {
-        runtimeHintValues: output.runtimeHintValues != null
-            ? deserializeAws_restJson1RuntimeHintValuesList(output.runtimeHintValues, context)
-            : undefined,
-        subSlotHints: output.subSlotHints != null ? deserializeAws_restJson1SlotHintsSlotMap(output.subSlotHints, context) : undefined,
+        runtimeHintValues: output.runtimeHintValues != null ? de_RuntimeHintValuesList(output.runtimeHintValues, context) : undefined,
+        subSlotHints: output.subSlotHints != null ? de_SlotHintsSlotMap(output.subSlotHints, context) : undefined,
     };
 };
-const deserializeAws_restJson1RuntimeHints = (output, context) => {
+const de_RuntimeHints = (output, context) => {
     return {
-        slotHints: output.slotHints != null ? deserializeAws_restJson1SlotHintsIntentMap(output.slotHints, context) : undefined,
+        slotHints: output.slotHints != null ? de_SlotHintsIntentMap(output.slotHints, context) : undefined,
     };
 };
-const deserializeAws_restJson1RuntimeHintValue = (output, context) => {
+const de_RuntimeHintValue = (output, context) => {
     return {
         phrase: __expectString(output.phrase),
     };
 };
-const deserializeAws_restJson1RuntimeHintValuesList = (output, context) => {
+const de_RuntimeHintValuesList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1RuntimeHintValue(entry, context);
+        return de_RuntimeHintValue(entry, context);
     });
     return retVal;
 };
-const deserializeAws_restJson1SentimentResponse = (output, context) => {
+const de_SentimentResponse = (output, context) => {
     return {
         sentiment: __expectString(output.sentiment),
-        sentimentScore: output.sentimentScore != null
-            ? deserializeAws_restJson1SentimentScore(output.sentimentScore, context)
-            : undefined,
+        sentimentScore: output.sentimentScore != null ? de_SentimentScore(output.sentimentScore, context) : undefined,
     };
 };
-const deserializeAws_restJson1SentimentScore = (output, context) => {
+const de_SentimentScore = (output, context) => {
     return {
         mixed: __limitedParseDouble(output.mixed),
         negative: __limitedParseDouble(output.negative),
@@ -1320,56 +1266,52 @@ const deserializeAws_restJson1SentimentScore = (output, context) => {
         positive: __limitedParseDouble(output.positive),
     };
 };
-const deserializeAws_restJson1SessionState = (output, context) => {
+const de_SessionState = (output, context) => {
     return {
-        activeContexts: output.activeContexts != null
-            ? deserializeAws_restJson1ActiveContextsList(output.activeContexts, context)
-            : undefined,
-        dialogAction: output.dialogAction != null ? deserializeAws_restJson1DialogAction(output.dialogAction, context) : undefined,
-        intent: output.intent != null ? deserializeAws_restJson1Intent(output.intent, context) : undefined,
+        activeContexts: output.activeContexts != null ? de_ActiveContextsList(output.activeContexts, context) : undefined,
+        dialogAction: output.dialogAction != null ? de_DialogAction(output.dialogAction, context) : undefined,
+        intent: output.intent != null ? de_Intent(output.intent, context) : undefined,
         originatingRequestId: __expectString(output.originatingRequestId),
-        runtimeHints: output.runtimeHints != null ? deserializeAws_restJson1RuntimeHints(output.runtimeHints, context) : undefined,
-        sessionAttributes: output.sessionAttributes != null
-            ? deserializeAws_restJson1StringMap(output.sessionAttributes, context)
-            : undefined,
+        runtimeHints: output.runtimeHints != null ? de_RuntimeHints(output.runtimeHints, context) : undefined,
+        sessionAttributes: output.sessionAttributes != null ? de_StringMap(output.sessionAttributes, context) : undefined,
     };
 };
-const deserializeAws_restJson1Slot = (output, context) => {
+const de_Slot = (output, context) => {
     return {
         shape: __expectString(output.shape),
-        subSlots: output.subSlots != null ? deserializeAws_restJson1Slots(output.subSlots, context) : undefined,
-        value: output.value != null ? deserializeAws_restJson1Value(output.value, context) : undefined,
-        values: output.values != null ? deserializeAws_restJson1Values(output.values, context) : undefined,
+        subSlots: output.subSlots != null ? de_Slots(output.subSlots, context) : undefined,
+        value: output.value != null ? de_Value(output.value, context) : undefined,
+        values: output.values != null ? de_Values(output.values, context) : undefined,
     };
 };
-const deserializeAws_restJson1SlotHintsIntentMap = (output, context) => {
+const de_SlotHintsIntentMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = deserializeAws_restJson1SlotHintsSlotMap(value, context);
+        acc[key] = de_SlotHintsSlotMap(value, context);
         return acc;
     }, {});
 };
-const deserializeAws_restJson1SlotHintsSlotMap = (output, context) => {
+const de_SlotHintsSlotMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = deserializeAws_restJson1RuntimeHintDetails(value, context);
+        acc[key] = de_RuntimeHintDetails(value, context);
         return acc;
     }, {});
 };
-const deserializeAws_restJson1Slots = (output, context) => {
+const de_Slots = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
         }
-        acc[key] = deserializeAws_restJson1Slot(value, context);
+        acc[key] = de_Slot(value, context);
         return acc;
     }, {});
 };
-const deserializeAws_restJson1StringList = (output, context) => {
+const de_StringList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -1380,7 +1322,7 @@ const deserializeAws_restJson1StringList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_restJson1StringMap = (output, context) => {
+const de_StringMap = (output, context) => {
     return Object.entries(output).reduce((acc, [key, value]) => {
         if (value === null) {
             return acc;
@@ -1389,33 +1331,33 @@ const deserializeAws_restJson1StringMap = (output, context) => {
         return acc;
     }, {});
 };
-const deserializeAws_restJson1TextResponseEvent = (output, context) => {
+const de_TextResponseEvent = (output, context) => {
     return {
         eventId: __expectString(output.eventId),
-        messages: output.messages != null ? deserializeAws_restJson1Messages(output.messages, context) : undefined,
+        messages: output.messages != null ? de_Messages(output.messages, context) : undefined,
     };
 };
-const deserializeAws_restJson1TranscriptEvent = (output, context) => {
+const de_TranscriptEvent = (output, context) => {
     return {
         eventId: __expectString(output.eventId),
         transcript: __expectString(output.transcript),
     };
 };
-const deserializeAws_restJson1Value = (output, context) => {
+const de_Value = (output, context) => {
     return {
         interpretedValue: __expectString(output.interpretedValue),
         originalValue: __expectString(output.originalValue),
-        resolvedValues: output.resolvedValues != null ? deserializeAws_restJson1StringList(output.resolvedValues, context) : undefined,
+        resolvedValues: output.resolvedValues != null ? de_StringList(output.resolvedValues, context) : undefined,
     };
 };
-const deserializeAws_restJson1Values = (output, context) => {
+const de_Values = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_restJson1Slot(entry, context);
+        return de_Slot(entry, context);
     });
     return retVal;
 };