@aws-sdk/client-lex-runtime-v2 3.131.0 → 3.135.0

package/dist-cjs/protocols/Aws_restJson1.js

@@ -378,7 +378,7 @@ const serializeAws_restJson1StartConversationCommand = async (input, context) =>
     }
     let body;
     if (input.requestEventStream !== undefined) {
-        body = context.eventStreamMarshaller.serialize(input.requestEventStream, (event) => serializeAws_restJson1StartConversationRequestEventStream_event(event, context));
+        body = serializeAws_restJson1StartConversationRequestEventStream(input.requestEventStream, context);
     }
     return new protocol_http_1.HttpRequest({
         protocol,
@@ -767,22 +767,8 @@ const deserializeAws_restJson1StartConversationCommand = async (output, context)
         $metadata: deserializeMetadata(output),
         responseEventStream: undefined,
     };
-    const data = context.eventStreamMarshaller.deserialize(output.body, async (event) => {
-        const eventName = Object.keys(event)[0];
-        const eventHeaders = Object.entries(event[eventName].headers).reduce((accummulator, curr) => {
-            accummulator[curr[0]] = curr[1].value;
-            return accummulator;
-        }, {});
-        const eventMessage = {
-            headers: eventHeaders,
-            body: event[eventName].body,
-        };
-        const parsedEvent = {
-            [eventName]: eventMessage,
-        };
-        return await deserializeAws_restJson1StartConversationResponseEventStream_event(parsedEvent, context);
-    });
-    contents.responseEventStream = data;
+    const data = output.body;
+    contents.responseEventStream = deserializeAws_restJson1StartConversationResponseEventStream(data, context);
     return Promise.resolve(contents);
 };
 exports.deserializeAws_restJson1StartConversationCommand = deserializeAws_restJson1StartConversationCommand;
@@ -818,167 +804,254 @@ const deserializeAws_restJson1StartConversationCommandError = async (output, con
             throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
-const serializeAws_restJson1StartConversationRequestEventStream_event = (input, context) => {
-    return models_0_1.StartConversationRequestEventStream.visit(input, {
-        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),
-        _: (value) => value,
+const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+    const contents = {};
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
+    }
+    const exception = new models_0_1.AccessDeniedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
     });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
-const deserializeAws_restJson1StartConversationResponseEventStream_event = async (output, context) => {
-    if (output["PlaybackInterruptionEvent"] !== undefined) {
-        return {
-            PlaybackInterruptionEvent: await deserializeAws_restJson1PlaybackInterruptionEvent_event(output["PlaybackInterruptionEvent"], context),
-        };
-    }
-    if (output["TranscriptEvent"] !== undefined) {
-        return {
-            TranscriptEvent: await deserializeAws_restJson1TranscriptEvent_event(output["TranscriptEvent"], context),
-        };
-    }
-    if (output["IntentResultEvent"] !== undefined) {
-        return {
-            IntentResultEvent: await deserializeAws_restJson1IntentResultEvent_event(output["IntentResultEvent"], context),
-        };
-    }
-    if (output["TextResponseEvent"] !== undefined) {
-        return {
-            TextResponseEvent: await deserializeAws_restJson1TextResponseEvent_event(output["TextResponseEvent"], context),
-        };
-    }
-    if (output["AudioResponseEvent"] !== undefined) {
-        return {
-            AudioResponseEvent: await deserializeAws_restJson1AudioResponseEvent_event(output["AudioResponseEvent"], context),
-        };
-    }
-    if (output["HeartbeatEvent"] !== undefined) {
-        return {
-            HeartbeatEvent: await deserializeAws_restJson1HeartbeatEvent_event(output["HeartbeatEvent"], context),
-        };
-    }
-    if (output["AccessDeniedException"] !== undefined) {
-        return {
-            AccessDeniedException: await deserializeAws_restJson1AccessDeniedException_event(output["AccessDeniedException"], context),
-        };
-    }
-    if (output["ResourceNotFoundException"] !== undefined) {
-        return {
-            ResourceNotFoundException: await deserializeAws_restJson1ResourceNotFoundException_event(output["ResourceNotFoundException"], context),
-        };
+const deserializeAws_restJson1BadGatewayExceptionResponse = async (parsedOutput, context) => {
+    const contents = {};
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
     }
-    if (output["ValidationException"] !== undefined) {
-        return {
-            ValidationException: await deserializeAws_restJson1ValidationException_event(output["ValidationException"], context),
-        };
+    const exception = new models_0_1.BadGatewayException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
+    const contents = {};
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
     }
-    if (output["ThrottlingException"] !== undefined) {
-        return {
-            ThrottlingException: await deserializeAws_restJson1ThrottlingException_event(output["ThrottlingException"], context),
-        };
+    const exception = new models_0_1.ConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1DependencyFailedExceptionResponse = async (parsedOutput, context) => {
+    const contents = {};
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
     }
-    if (output["InternalServerException"] !== undefined) {
-        return {
-            InternalServerException: await deserializeAws_restJson1InternalServerException_event(output["InternalServerException"], context),
-        };
+    const exception = new models_0_1.DependencyFailedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOutput, context) => {
+    const contents = {};
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
     }
-    if (output["ConflictException"] !== undefined) {
-        return {
-            ConflictException: await deserializeAws_restJson1ConflictException_event(output["ConflictException"], context),
-        };
+    const exception = new models_0_1.InternalServerException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const contents = {};
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
     }
-    if (output["DependencyFailedException"] !== undefined) {
-        return {
-            DependencyFailedException: await deserializeAws_restJson1DependencyFailedException_event(output["DependencyFailedException"], context),
-        };
+    const exception = new models_0_1.ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput, context) => {
+    const contents = {};
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
     }
-    if (output["BadGatewayException"] !== undefined) {
-        return {
-            BadGatewayException: await deserializeAws_restJson1BadGatewayException_event(output["BadGatewayException"], context),
-        };
+    const exception = new models_0_1.ThrottlingException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput, context) => {
+    const contents = {};
+    const data = parsedOutput.body;
+    if (data.message !== undefined && data.message !== null) {
+        contents.message = (0, smithy_client_1.expectString)(data.message);
     }
-    return { $unknown: output };
+    const exception = new models_0_1.ValidationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const serializeAws_restJson1StartConversationRequestEventStream = (input, context) => {
+    const eventMarshallingVisitor = (event) => models_0_1.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),
+        _: (value) => value,
+    });
+    return context.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
 };
 const serializeAws_restJson1AudioInputEvent_event = (input, context) => {
-    const message = {
-        headers: {
-            ":event-type": { type: "string", value: "AudioInputEvent" },
-            ":message-type": { type: "string", value: "event" },
-            ":content-type": { type: "string", value: "application/json" },
-        },
-        body: new Uint8Array(),
-    };
-    const body = serializeAws_restJson1AudioInputEvent(input, context);
-    message.body = context.utf8Decoder(JSON.stringify(body));
-    return message;
+    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 = context.utf8Decoder(JSON.stringify(body));
+    return { headers, body };
 };
 const serializeAws_restJson1ConfigurationEvent_event = (input, context) => {
-    const message = {
-        headers: {
-            ":event-type": { type: "string", value: "ConfigurationEvent" },
-            ":message-type": { type: "string", value: "event" },
-            ":content-type": { type: "string", value: "application/json" },
-        },
-        body: new Uint8Array(),
-    };
-    const body = serializeAws_restJson1ConfigurationEvent(input, context);
-    message.body = context.utf8Decoder(JSON.stringify(body));
-    return message;
+    const headers = {
+        ":event-type": { type: "string", value: "ConfigurationEvent" },
+        ":message-type": { type: "string", value: "event" },
+        ":content-type": { type: "string", value: "application/json" },
+    };
+    let body = new Uint8Array();
+    body = serializeAws_restJson1ConfigurationEvent(input, context);
+    body = context.utf8Decoder(JSON.stringify(body));
+    return { headers, body };
 };
 const serializeAws_restJson1DisconnectionEvent_event = (input, context) => {
-    const message = {
-        headers: {
-            ":event-type": { type: "string", value: "DisconnectionEvent" },
-            ":message-type": { type: "string", value: "event" },
-            ":content-type": { type: "string", value: "application/json" },
-        },
-        body: new Uint8Array(),
-    };
-    const body = serializeAws_restJson1DisconnectionEvent(input, context);
-    message.body = context.utf8Decoder(JSON.stringify(body));
-    return message;
+    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 = context.utf8Decoder(JSON.stringify(body));
+    return { headers, body };
 };
 const serializeAws_restJson1DTMFInputEvent_event = (input, context) => {
-    const message = {
-        headers: {
-            ":event-type": { type: "string", value: "DTMFInputEvent" },
-            ":message-type": { type: "string", value: "event" },
-            ":content-type": { type: "string", value: "application/json" },
-        },
-        body: new Uint8Array(),
-    };
-    const body = serializeAws_restJson1DTMFInputEvent(input, context);
-    message.body = context.utf8Decoder(JSON.stringify(body));
-    return message;
+    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 = context.utf8Decoder(JSON.stringify(body));
+    return { headers, body };
 };
 const serializeAws_restJson1PlaybackCompletionEvent_event = (input, context) => {
-    const message = {
-        headers: {
-            ":event-type": { type: "string", value: "PlaybackCompletionEvent" },
-            ":message-type": { type: "string", value: "event" },
-            ":content-type": { type: "string", value: "application/json" },
-        },
-        body: new Uint8Array(),
-    };
-    const body = serializeAws_restJson1PlaybackCompletionEvent(input, context);
-    message.body = context.utf8Decoder(JSON.stringify(body));
-    return message;
+    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 = context.utf8Decoder(JSON.stringify(body));
+    return { headers, body };
 };
 const serializeAws_restJson1TextInputEvent_event = (input, context) => {
-    const message = {
-        headers: {
-            ":event-type": { type: "string", value: "TextInputEvent" },
-            ":message-type": { type: "string", value: "event" },
-            ":content-type": { type: "string", value: "application/json" },
-        },
-        body: new Uint8Array(),
-    };
-    const body = serializeAws_restJson1TextInputEvent(input, context);
-    message.body = context.utf8Decoder(JSON.stringify(body));
-    return message;
+    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 = context.utf8Decoder(JSON.stringify(body));
+    return { headers, body };
+};
+const deserializeAws_restJson1StartConversationResponseEventStream = (output, context) => {
+    return context.eventStreamMarshaller.deserialize(output, async (event) => {
+        if (event["PlaybackInterruptionEvent"] != null) {
+            return {
+                PlaybackInterruptionEvent: await deserializeAws_restJson1PlaybackInterruptionEvent_event(event["PlaybackInterruptionEvent"], context),
+            };
+        }
+        if (event["TranscriptEvent"] != null) {
+            return {
+                TranscriptEvent: await deserializeAws_restJson1TranscriptEvent_event(event["TranscriptEvent"], context),
+            };
+        }
+        if (event["IntentResultEvent"] != null) {
+            return {
+                IntentResultEvent: await deserializeAws_restJson1IntentResultEvent_event(event["IntentResultEvent"], context),
+            };
+        }
+        if (event["TextResponseEvent"] != null) {
+            return {
+                TextResponseEvent: await deserializeAws_restJson1TextResponseEvent_event(event["TextResponseEvent"], context),
+            };
+        }
+        if (event["AudioResponseEvent"] != null) {
+            return {
+                AudioResponseEvent: await deserializeAws_restJson1AudioResponseEvent_event(event["AudioResponseEvent"], context),
+            };
+        }
+        if (event["HeartbeatEvent"] != null) {
+            return {
+                HeartbeatEvent: await deserializeAws_restJson1HeartbeatEvent_event(event["HeartbeatEvent"], context),
+            };
+        }
+        if (event["AccessDeniedException"] != null) {
+            return {
+                AccessDeniedException: await deserializeAws_restJson1AccessDeniedException_event(event["AccessDeniedException"], context),
+            };
+        }
+        if (event["ResourceNotFoundException"] != null) {
+            return {
+                ResourceNotFoundException: await deserializeAws_restJson1ResourceNotFoundException_event(event["ResourceNotFoundException"], context),
+            };
+        }
+        if (event["ValidationException"] != null) {
+            return {
+                ValidationException: await deserializeAws_restJson1ValidationException_event(event["ValidationException"], context),
+            };
+        }
+        if (event["ThrottlingException"] != null) {
+            return {
+                ThrottlingException: await deserializeAws_restJson1ThrottlingException_event(event["ThrottlingException"], context),
+            };
+        }
+        if (event["InternalServerException"] != null) {
+            return {
+                InternalServerException: await deserializeAws_restJson1InternalServerException_event(event["InternalServerException"], context),
+            };
+        }
+        if (event["ConflictException"] != null) {
+            return {
+                ConflictException: await deserializeAws_restJson1ConflictException_event(event["ConflictException"], context),
+            };
+        }
+        if (event["DependencyFailedException"] != null) {
+            return {
+                DependencyFailedException: await deserializeAws_restJson1DependencyFailedException_event(event["DependencyFailedException"], context),
+            };
+        }
+        if (event["BadGatewayException"] != null) {
+            return {
+                BadGatewayException: await deserializeAws_restJson1BadGatewayException_event(event["BadGatewayException"], context),
+            };
+        }
+        return { $unknown: output };
+    });
 };
 const deserializeAws_restJson1AccessDeniedException_event = async (output, context) => {
     const parsedOutput = {
@@ -988,12 +1061,9 @@ const deserializeAws_restJson1AccessDeniedException_event = async (output, conte
     return deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
 };
 const deserializeAws_restJson1AudioResponseEvent_event = async (output, context) => {
-    let contents = {};
+    const contents = {};
     const data = await parseBody(output.body, context);
-    contents = {
-        ...contents,
-        ...deserializeAws_restJson1AudioResponseEvent(data, context),
-    };
+    Object.assign(contents, deserializeAws_restJson1AudioResponseEvent(data, context));
     return contents;
 };
 const deserializeAws_restJson1BadGatewayException_event = async (output, context) => {
@@ -1018,21 +1088,15 @@ const deserializeAws_restJson1DependencyFailedException_event = async (output, c
     return deserializeAws_restJson1DependencyFailedExceptionResponse(parsedOutput, context);
 };
 const deserializeAws_restJson1HeartbeatEvent_event = async (output, context) => {
-    let contents = {};
+    const contents = {};
     const data = await parseBody(output.body, context);
-    contents = {
-        ...contents,
-        ...deserializeAws_restJson1HeartbeatEvent(data, context),
-    };
+    Object.assign(contents, deserializeAws_restJson1HeartbeatEvent(data, context));
     return contents;
 };
 const deserializeAws_restJson1IntentResultEvent_event = async (output, context) => {
-    let contents = {};
+    const contents = {};
     const data = await parseBody(output.body, context);
-    contents = {
-        ...contents,
-        ...deserializeAws_restJson1IntentResultEvent(data, context),
-    };
+    Object.assign(contents, deserializeAws_restJson1IntentResultEvent(data, context));
     return contents;
 };
 const deserializeAws_restJson1InternalServerException_event = async (output, context) => {
@@ -1043,12 +1107,9 @@ const deserializeAws_restJson1InternalServerException_event = async (output, con
     return deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
 };
 const deserializeAws_restJson1PlaybackInterruptionEvent_event = async (output, context) => {
-    let contents = {};
+    const contents = {};
     const data = await parseBody(output.body, context);
-    contents = {
-        ...contents,
-        ...deserializeAws_restJson1PlaybackInterruptionEvent(data, context),
-    };
+    Object.assign(contents, deserializeAws_restJson1PlaybackInterruptionEvent(data, context));
     return contents;
 };
 const deserializeAws_restJson1ResourceNotFoundException_event = async (output, context) => {
@@ -1059,12 +1120,9 @@ const deserializeAws_restJson1ResourceNotFoundException_event = async (output, c
     return deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
 };
 const deserializeAws_restJson1TextResponseEvent_event = async (output, context) => {
-    let contents = {};
+    const contents = {};
     const data = await parseBody(output.body, context);
-    contents = {
-        ...contents,
-        ...deserializeAws_restJson1TextResponseEvent(data, context),
-    };
+    Object.assign(contents, deserializeAws_restJson1TextResponseEvent(data, context));
     return contents;
 };
 const deserializeAws_restJson1ThrottlingException_event = async (output, context) => {
@@ -1075,12 +1133,9 @@ const deserializeAws_restJson1ThrottlingException_event = async (output, context
     return deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
 };
 const deserializeAws_restJson1TranscriptEvent_event = async (output, context) => {
-    let contents = {};
+    const contents = {};
     const data = await parseBody(output.body, context);
-    contents = {
-        ...contents,
-        ...deserializeAws_restJson1TranscriptEvent(data, context),
-    };
+    Object.assign(contents, deserializeAws_restJson1TranscriptEvent(data, context));
     return contents;
 };
 const deserializeAws_restJson1ValidationException_event = async (output, context) => {
@@ -1090,102 +1145,6 @@ const deserializeAws_restJson1ValidationException_event = async (output, context
     };
     return deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
 };
-const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
-    const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
-        contents.message = (0, smithy_client_1.expectString)(data.message);
-    }
-    const exception = new models_0_1.AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
-};
-const deserializeAws_restJson1BadGatewayExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
-    const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
-        contents.message = (0, smithy_client_1.expectString)(data.message);
-    }
-    const exception = new models_0_1.BadGatewayException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
-};
-const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
-    const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
-        contents.message = (0, smithy_client_1.expectString)(data.message);
-    }
-    const exception = new models_0_1.ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
-};
-const deserializeAws_restJson1DependencyFailedExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
-    const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
-        contents.message = (0, smithy_client_1.expectString)(data.message);
-    }
-    const exception = new models_0_1.DependencyFailedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
-};
-const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
-    const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
-        contents.message = (0, smithy_client_1.expectString)(data.message);
-    }
-    const exception = new models_0_1.InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
-};
-const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
-    const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
-        contents.message = (0, smithy_client_1.expectString)(data.message);
-    }
-    const exception = new models_0_1.ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
-};
-const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
-    const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
-        contents.message = (0, smithy_client_1.expectString)(data.message);
-    }
-    const exception = new models_0_1.ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
-};
-const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
-    const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
-        contents.message = (0, smithy_client_1.expectString)(data.message);
-    }
-    const exception = new models_0_1.ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
-};
 const serializeAws_restJson1ActiveContext = (input, context) => {
     return {
         ...(input.contextAttributes != null && {
@@ -1411,19 +1370,6 @@ const serializeAws_restJson1Slots = (input, context) => {
         };
     }, {});
 };
-const serializeAws_restJson1StartConversationRequestEventStream = (input, context) => {
-    return models_0_1.StartConversationRequestEventStream.visit(input, {
-        AudioInputEvent: (value) => ({ AudioInputEvent: serializeAws_restJson1AudioInputEvent(value, context) }),
-        ConfigurationEvent: (value) => ({ ConfigurationEvent: serializeAws_restJson1ConfigurationEvent(value, context) }),
-        DTMFInputEvent: (value) => ({ DTMFInputEvent: serializeAws_restJson1DTMFInputEvent(value, context) }),
-        DisconnectionEvent: (value) => ({ DisconnectionEvent: serializeAws_restJson1DisconnectionEvent(value, context) }),
-        PlaybackCompletionEvent: (value) => ({
-            PlaybackCompletionEvent: serializeAws_restJson1PlaybackCompletionEvent(value, context),
-        }),
-        TextInputEvent: (value) => ({ TextInputEvent: serializeAws_restJson1TextInputEvent(value, context) }),
-        _: (name, value) => ({ name: value }),
-    });
-};
 const serializeAws_restJson1StringList = (input, context) => {
     return input
         .filter((e) => e != null)
@@ -1471,11 +1417,6 @@ const serializeAws_restJson1Values = (input, context) => {
         return serializeAws_restJson1Slot(entry, context);
     });
 };
-const deserializeAws_restJson1AccessDeniedException = (output, context) => {
-    return {
-        message: (0, smithy_client_1.expectString)(output.message),
-    };
-};
 const deserializeAws_restJson1ActiveContext = (output, context) => {
     return {
         contextAttributes: output.contextAttributes != null
@@ -1522,11 +1463,6 @@ const deserializeAws_restJson1AudioResponseEvent = (output, context) => {
         eventId: (0, smithy_client_1.expectString)(output.eventId),
     };
 };
-const deserializeAws_restJson1BadGatewayException = (output, context) => {
-    return {
-        message: (0, smithy_client_1.expectString)(output.message),
-    };
-};
 const deserializeAws_restJson1Button = (output, context) => {
     return {
         text: (0, smithy_client_1.expectString)(output.text),
@@ -1549,16 +1485,6 @@ const deserializeAws_restJson1ConfidenceScore = (output, context) => {
         score: (0, smithy_client_1.limitedParseDouble)(output.score),
     };
 };
-const deserializeAws_restJson1ConflictException = (output, context) => {
-    return {
-        message: (0, smithy_client_1.expectString)(output.message),
-    };
-};
-const deserializeAws_restJson1DependencyFailedException = (output, context) => {
-    return {
-        message: (0, smithy_client_1.expectString)(output.message),
-    };
-};
 const deserializeAws_restJson1DialogAction = (output, context) => {
     return {
         slotElicitationStyle: (0, smithy_client_1.expectString)(output.slotElicitationStyle),
@@ -1601,11 +1527,6 @@ const deserializeAws_restJson1IntentResultEvent = (output, context) => {
         sessionState: output.sessionState != null ? deserializeAws_restJson1SessionState(output.sessionState, context) : undefined,
     };
 };
-const deserializeAws_restJson1InternalServerException = (output, context) => {
-    return {
-        message: (0, smithy_client_1.expectString)(output.message),
-    };
-};
 const deserializeAws_restJson1Interpretation = (output, context) => {
     return {
         intent: output.intent != null ? deserializeAws_restJson1Intent(output.intent, context) : undefined,
@@ -1653,11 +1574,6 @@ const deserializeAws_restJson1PlaybackInterruptionEvent = (output, context) => {
         eventReason: (0, smithy_client_1.expectString)(output.eventReason),
     };
 };
-const deserializeAws_restJson1ResourceNotFoundException = (output, context) => {
-    return {
-        message: (0, smithy_client_1.expectString)(output.message),
-    };
-};
 const deserializeAws_restJson1RuntimeHintDetails = (output, context) => {
     return {
         runtimeHintValues: output.runtimeHintValues != null
@@ -1756,79 +1672,6 @@ const deserializeAws_restJson1Slots = (output, context) => {
         };
     }, {});
 };
-const deserializeAws_restJson1StartConversationResponseEventStream = (output, context) => {
-    if (output.AccessDeniedException !== undefined && output.AccessDeniedException !== null) {
-        return {
-            AccessDeniedException: deserializeAws_restJson1AccessDeniedException(output.AccessDeniedException, context),
-        };
-    }
-    if (output.AudioResponseEvent !== undefined && output.AudioResponseEvent !== null) {
-        return {
-            AudioResponseEvent: deserializeAws_restJson1AudioResponseEvent(output.AudioResponseEvent, context),
-        };
-    }
-    if (output.BadGatewayException !== undefined && output.BadGatewayException !== null) {
-        return {
-            BadGatewayException: deserializeAws_restJson1BadGatewayException(output.BadGatewayException, context),
-        };
-    }
-    if (output.ConflictException !== undefined && output.ConflictException !== null) {
-        return {
-            ConflictException: deserializeAws_restJson1ConflictException(output.ConflictException, context),
-        };
-    }
-    if (output.DependencyFailedException !== undefined && output.DependencyFailedException !== null) {
-        return {
-            DependencyFailedException: deserializeAws_restJson1DependencyFailedException(output.DependencyFailedException, context),
-        };
-    }
-    if (output.HeartbeatEvent !== undefined && output.HeartbeatEvent !== null) {
-        return {
-            HeartbeatEvent: deserializeAws_restJson1HeartbeatEvent(output.HeartbeatEvent, context),
-        };
-    }
-    if (output.IntentResultEvent !== undefined && output.IntentResultEvent !== null) {
-        return {
-            IntentResultEvent: deserializeAws_restJson1IntentResultEvent(output.IntentResultEvent, context),
-        };
-    }
-    if (output.InternalServerException !== undefined && output.InternalServerException !== null) {
-        return {
-            InternalServerException: deserializeAws_restJson1InternalServerException(output.InternalServerException, context),
-        };
-    }
-    if (output.PlaybackInterruptionEvent !== undefined && output.PlaybackInterruptionEvent !== null) {
-        return {
-            PlaybackInterruptionEvent: deserializeAws_restJson1PlaybackInterruptionEvent(output.PlaybackInterruptionEvent, context),
-        };
-    }
-    if (output.ResourceNotFoundException !== undefined && output.ResourceNotFoundException !== null) {
-        return {
-            ResourceNotFoundException: deserializeAws_restJson1ResourceNotFoundException(output.ResourceNotFoundException, context),
-        };
-    }
-    if (output.TextResponseEvent !== undefined && output.TextResponseEvent !== null) {
-        return {
-            TextResponseEvent: deserializeAws_restJson1TextResponseEvent(output.TextResponseEvent, context),
-        };
-    }
-    if (output.ThrottlingException !== undefined && output.ThrottlingException !== null) {
-        return {
-            ThrottlingException: deserializeAws_restJson1ThrottlingException(output.ThrottlingException, context),
-        };
-    }
-    if (output.TranscriptEvent !== undefined && output.TranscriptEvent !== null) {
-        return {
-            TranscriptEvent: deserializeAws_restJson1TranscriptEvent(output.TranscriptEvent, context),
-        };
-    }
-    if (output.ValidationException !== undefined && output.ValidationException !== null) {
-        return {
-            ValidationException: deserializeAws_restJson1ValidationException(output.ValidationException, context),
-        };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
 const deserializeAws_restJson1StringList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -1857,22 +1700,12 @@ const deserializeAws_restJson1TextResponseEvent = (output, context) => {
         messages: output.messages != null ? deserializeAws_restJson1Messages(output.messages, context) : undefined,
     };
 };
-const deserializeAws_restJson1ThrottlingException = (output, context) => {
-    return {
-        message: (0, smithy_client_1.expectString)(output.message),
-    };
-};
 const deserializeAws_restJson1TranscriptEvent = (output, context) => {
     return {
         eventId: (0, smithy_client_1.expectString)(output.eventId),
         transcript: (0, smithy_client_1.expectString)(output.transcript),
     };
 };
-const deserializeAws_restJson1ValidationException = (output, context) => {
-    return {
-        message: (0, smithy_client_1.expectString)(output.message),
-    };
-};
 const deserializeAws_restJson1Value = (output, context) => {
     return {
         interpretedValue: (0, smithy_client_1.expectString)(output.interpretedValue),