@aws-sdk/client-lex-runtime-v2 3.928.0 → 3.929.0

package/dist-cjs/index.js

@@ -7,6 +7,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var eventstreamSerdeConfigResolver = require('@smithy/eventstream-serde-config-resolver');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
@@ -16,8 +17,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -95,6 +94,7 @@ class LexRuntimeV2Client extends smithyClient.Client {
         const _config_9 = middlewareEventstream.resolveEventStreamConfig(_config_8);
         const _config_10 = resolveRuntimeExtensions(_config_9, configuration?.extensions || []);
         this.config = _config_10;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -114,14 +114,14 @@ class LexRuntimeV2Client extends smithyClient.Client {
     }
 }
 
-class LexRuntimeV2ServiceException extends smithyClient.ServiceException {
+let LexRuntimeV2ServiceException$1 = class LexRuntimeV2ServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, LexRuntimeV2ServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends LexRuntimeV2ServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends LexRuntimeV2ServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -132,8 +132,8 @@ class AccessDeniedException extends LexRuntimeV2ServiceException {
         });
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
     }
-}
-class ConflictException extends LexRuntimeV2ServiceException {
+};
+let ConflictException$1 = class ConflictException extends LexRuntimeV2ServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     constructor(opts) {
@@ -144,8 +144,8 @@ class ConflictException extends LexRuntimeV2ServiceException {
         });
         Object.setPrototypeOf(this, ConflictException.prototype);
     }
-}
-class InternalServerException extends LexRuntimeV2ServiceException {
+};
+let InternalServerException$1 = class InternalServerException extends LexRuntimeV2ServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     constructor(opts) {
@@ -156,8 +156,8 @@ class InternalServerException extends LexRuntimeV2ServiceException {
         });
         Object.setPrototypeOf(this, InternalServerException.prototype);
     }
-}
-class ResourceNotFoundException extends LexRuntimeV2ServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends LexRuntimeV2ServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -168,8 +168,8 @@ class ResourceNotFoundException extends LexRuntimeV2ServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
-class ThrottlingException extends LexRuntimeV2ServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends LexRuntimeV2ServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     constructor(opts) {
@@ -180,8 +180,8 @@ class ThrottlingException extends LexRuntimeV2ServiceException {
         });
         Object.setPrototypeOf(this, ThrottlingException.prototype);
     }
-}
-class ValidationException extends LexRuntimeV2ServiceException {
+};
+let ValidationException$1 = class ValidationException extends LexRuntimeV2ServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     constructor(opts) {
@@ -192,7 +192,7 @@ class ValidationException extends LexRuntimeV2ServiceException {
         });
         Object.setPrototypeOf(this, ValidationException.prototype);
     }
-}
+};
 const ConfirmationState = {
     CONFIRMED: "Confirmed",
     DENIED: "Denied",
@@ -240,7 +240,7 @@ const DialogActionType = {
     ELICIT_SLOT: "ElicitSlot",
     NONE: "None",
 };
-class BadGatewayException extends LexRuntimeV2ServiceException {
+let BadGatewayException$1 = class BadGatewayException extends LexRuntimeV2ServiceException$1 {
     name = "BadGatewayException";
     $fault = "server";
     constructor(opts) {
@@ -251,8 +251,8 @@ class BadGatewayException extends LexRuntimeV2ServiceException {
         });
         Object.setPrototypeOf(this, BadGatewayException.prototype);
     }
-}
-class DependencyFailedException extends LexRuntimeV2ServiceException {
+};
+let DependencyFailedException$1 = class DependencyFailedException extends LexRuntimeV2ServiceException$1 {
     name = "DependencyFailedException";
     $fault = "client";
     constructor(opts) {
@@ -263,7 +263,7 @@ class DependencyFailedException extends LexRuntimeV2ServiceException {
         });
         Object.setPrototypeOf(this, DependencyFailedException.prototype);
     }
-}
+};
 const ConversationMode = {
     AUDIO: "AUDIO",
     TEXT: "TEXT",
@@ -330,981 +330,167 @@ exports.StartConversationResponseEventStream = void 0;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(exports.StartConversationResponseEventStream || (exports.StartConversationResponseEventStream = {}));
-const ActiveContextFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.contextAttributes && { contextAttributes: smithyClient.SENSITIVE_STRING }),
-});
-const MessageFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.content && { content: smithyClient.SENSITIVE_STRING }),
-});
-const PutSessionResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-const RecognizeUtteranceRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.sessionState && { sessionState: smithyClient.SENSITIVE_STRING }),
-    ...(obj.requestAttributes && { requestAttributes: smithyClient.SENSITIVE_STRING }),
-});
-const RecognizeUtteranceResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-const DTMFInputEventFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.inputCharacter && { inputCharacter: smithyClient.SENSITIVE_STRING }),
-});
-const TextInputEventFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.text && { text: smithyClient.SENSITIVE_STRING }),
-});
-const TextResponseEventFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.messages && { messages: obj.messages.map((item) => MessageFilterSensitiveLog(item)) }),
-});
-const SessionStateFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.activeContexts && {
-        activeContexts: obj.activeContexts.map((item) => ActiveContextFilterSensitiveLog(item)),
-    }),
-});
-const ConfigurationEventFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.welcomeMessages && { welcomeMessages: obj.welcomeMessages.map((item) => MessageFilterSensitiveLog(item)) }),
-});
-const PutSessionRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.messages && { messages: obj.messages.map((item) => MessageFilterSensitiveLog(item)) }),
-});
-const RecognizeTextRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.text && { text: smithyClient.SENSITIVE_STRING }),
-});
-const StartConversationRequestEventStreamFilterSensitiveLog = (obj) => {
-    if (obj.ConfigurationEvent !== undefined)
-        return { ConfigurationEvent: ConfigurationEventFilterSensitiveLog(obj.ConfigurationEvent) };
-    if (obj.AudioInputEvent !== undefined)
-        return { AudioInputEvent: obj.AudioInputEvent };
-    if (obj.DTMFInputEvent !== undefined)
-        return { DTMFInputEvent: DTMFInputEventFilterSensitiveLog(obj.DTMFInputEvent) };
-    if (obj.TextInputEvent !== undefined)
-        return { TextInputEvent: TextInputEventFilterSensitiveLog(obj.TextInputEvent) };
-    if (obj.PlaybackCompletionEvent !== undefined)
-        return { PlaybackCompletionEvent: obj.PlaybackCompletionEvent };
-    if (obj.DisconnectionEvent !== undefined)
-        return { DisconnectionEvent: obj.DisconnectionEvent };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const StartConversationRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.requestEventStream && { requestEventStream: "STREAMING_CONTENT" }),
-});
-const GetSessionResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.messages && { messages: obj.messages.map((item) => MessageFilterSensitiveLog(item)) }),
-});
-const IntentResultEventFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-const RecognizeTextResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.messages && { messages: obj.messages.map((item) => MessageFilterSensitiveLog(item)) }),
-});
-const StartConversationResponseEventStreamFilterSensitiveLog = (obj) => {
-    if (obj.PlaybackInterruptionEvent !== undefined)
-        return { PlaybackInterruptionEvent: obj.PlaybackInterruptionEvent };
-    if (obj.TranscriptEvent !== undefined)
-        return { TranscriptEvent: obj.TranscriptEvent };
-    if (obj.IntentResultEvent !== undefined)
-        return { IntentResultEvent: IntentResultEventFilterSensitiveLog(obj.IntentResultEvent) };
-    if (obj.TextResponseEvent !== undefined)
-        return { TextResponseEvent: TextResponseEventFilterSensitiveLog(obj.TextResponseEvent) };
-    if (obj.AudioResponseEvent !== undefined)
-        return { AudioResponseEvent: obj.AudioResponseEvent };
-    if (obj.HeartbeatEvent !== undefined)
-        return { HeartbeatEvent: obj.HeartbeatEvent };
-    if (obj.AccessDeniedException !== undefined)
-        return { AccessDeniedException: obj.AccessDeniedException };
-    if (obj.ResourceNotFoundException !== undefined)
-        return { ResourceNotFoundException: obj.ResourceNotFoundException };
-    if (obj.ValidationException !== undefined)
-        return { ValidationException: obj.ValidationException };
-    if (obj.ThrottlingException !== undefined)
-        return { ThrottlingException: obj.ThrottlingException };
-    if (obj.InternalServerException !== undefined)
-        return { InternalServerException: obj.InternalServerException };
-    if (obj.ConflictException !== undefined)
-        return { ConflictException: obj.ConflictException };
-    if (obj.DependencyFailedException !== undefined)
-        return { DependencyFailedException: obj.DependencyFailedException };
-    if (obj.BadGatewayException !== undefined)
-        return { BadGatewayException: obj.BadGatewayException };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const StartConversationResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.responseEventStream && { responseEventStream: "STREAMING_CONTENT" }),
-});
 
-const se_DeleteSessionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/bots/{botId}/botAliases/{botAliasId}/botLocales/{localeId}/sessions/{sessionId}");
-    b.p("botId", () => input.botId, "{botId}", false);
-    b.p("botAliasId", () => input.botAliasId, "{botAliasId}", false);
-    b.p("localeId", () => input.localeId, "{localeId}", false);
-    b.p("sessionId", () => input.sessionId, "{sessionId}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_GetSessionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/bots/{botId}/botAliases/{botAliasId}/botLocales/{localeId}/sessions/{sessionId}");
-    b.p("botId", () => input.botId, "{botId}", false);
-    b.p("botAliasId", () => input.botAliasId, "{botAliasId}", false);
-    b.p("localeId", () => input.localeId, "{localeId}", false);
-    b.p("sessionId", () => input.sessionId, "{sessionId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_PutSessionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
-        "content-type": "application/json",
-        [_r]: input[_rCT],
-    });
-    b.bp("/bots/{botId}/botAliases/{botAliasId}/botLocales/{localeId}/sessions/{sessionId}");
-    b.p("botId", () => input.botId, "{botId}", false);
-    b.p("botAliasId", () => input.botAliasId, "{botAliasId}", false);
-    b.p("localeId", () => input.localeId, "{localeId}", false);
-    b.p("sessionId", () => input.sessionId, "{sessionId}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        messages: (_) => smithyClient._json(_),
-        requestAttributes: (_) => smithyClient._json(_),
-        sessionState: (_) => se_SessionState(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_RecognizeTextCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/bots/{botId}/botAliases/{botAliasId}/botLocales/{localeId}/sessions/{sessionId}/text");
-    b.p("botId", () => input.botId, "{botId}", false);
-    b.p("botAliasId", () => input.botAliasId, "{botAliasId}", false);
-    b.p("localeId", () => input.localeId, "{localeId}", false);
-    b.p("sessionId", () => input.sessionId, "{sessionId}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        requestAttributes: (_) => smithyClient._json(_),
-        sessionState: (_) => se_SessionState(_),
-        text: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_RecognizeUtteranceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
-        "x-amz-content-sha256": "UNSIGNED-PAYLOAD",
-        [_ct]: input[_rCTe] || "application/octet-stream",
-        [_xalss]: input[_sS],
-        [_xalra]: input[_rA],
-        [_rct]: input[_rCT],
-    });
-    b.bp("/bots/{botId}/botAliases/{botAliasId}/botLocales/{localeId}/sessions/{sessionId}/utterance");
-    b.p("botId", () => input.botId, "{botId}", false);
-    b.p("botAliasId", () => input.botAliasId, "{botAliasId}", false);
-    b.p("localeId", () => input.localeId, "{localeId}", false);
-    b.p("sessionId", () => input.sessionId, "{sessionId}", false);
-    let body;
-    if (input.inputStream !== undefined) {
-        body = input.inputStream;
-    }
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartConversationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
-        "content-type": "application/json",
-        [_xalcm]: input[_cM],
-    });
-    b.bp("/bots/{botId}/botAliases/{botAliasId}/botLocales/{localeId}/sessions/{sessionId}/conversation");
-    b.p("botId", () => input.botId, "{botId}", false);
-    b.p("botAliasId", () => input.botAliasId, "{botAliasId}", false);
-    b.p("localeId", () => input.localeId, "{localeId}", false);
-    b.p("sessionId", () => input.sessionId, "{sessionId}", false);
-    let body;
-    if (input.requestEventStream !== undefined) {
-        body = se_StartConversationRequestEventStream(input.requestEventStream, context);
-    }
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_DeleteSessionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        botAliasId: smithyClient.expectString,
-        botId: smithyClient.expectString,
-        localeId: smithyClient.expectString,
-        sessionId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetSessionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        interpretations: (_) => de_Interpretations(_),
-        messages: smithyClient._json,
-        sessionId: smithyClient.expectString,
-        sessionState: (_) => de_SessionState(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_PutSessionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_cT]: [, output.headers[_ct]],
-        [_m]: [, output.headers[_xalm]],
-        [_sS]: [, output.headers[_xalss]],
-        [_rA]: [, output.headers[_xalra]],
-        [_sI]: [, output.headers[_xalsi]],
-    });
-    const data = output.body;
-    context.sdkStreamMixin(data);
-    contents.audioStream = data;
-    return contents;
-};
-const de_RecognizeTextCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        interpretations: (_) => de_Interpretations(_),
-        messages: smithyClient._json,
-        recognizedBotMember: smithyClient._json,
-        requestAttributes: smithyClient._json,
-        sessionId: smithyClient.expectString,
-        sessionState: (_) => de_SessionState(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_RecognizeUtteranceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_iM]: [, output.headers[_xalim]],
-        [_cT]: [, output.headers[_ct]],
-        [_m]: [, output.headers[_xalm]],
-        [_i]: [, output.headers[_xali]],
-        [_sS]: [, output.headers[_xalss]],
-        [_rA]: [, output.headers[_xalra]],
-        [_sI]: [, output.headers[_xalsi]],
-        [_iT]: [, output.headers[_xalit]],
-        [_rBM]: [, output.headers[_xalrbm]],
-    });
-    const data = output.body;
-    context.sdkStreamMixin(data);
-    contents.audioStream = data;
-    return contents;
-};
-const de_StartConversationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = output.body;
-    contents.responseEventStream = de_StartConversationResponseEventStream(data, context);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.lexruntimev2#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.lexruntimev2#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.lexruntimev2#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.lexruntimev2#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.lexruntimev2#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.lexruntimev2#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "BadGatewayException":
-        case "com.amazonaws.lexruntimev2#BadGatewayException":
-            throw await de_BadGatewayExceptionRes(parsedOutput);
-        case "DependencyFailedException":
-        case "com.amazonaws.lexruntimev2#DependencyFailedException":
-            throw await de_DependencyFailedExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(LexRuntimeV2ServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_BadGatewayExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new BadGatewayException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_DependencyFailedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new DependencyFailedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_StartConversationRequestEventStream = (input, context) => {
-    const eventMarshallingVisitor = (event) => exports.StartConversationRequestEventStream.visit(event, {
-        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 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 = se_AudioInputEvent(input, context);
-    body = context.utf8Decoder(JSON.stringify(body));
-    return { headers, body };
-};
-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 = se_ConfigurationEvent(input);
-    body = context.utf8Decoder(JSON.stringify(body));
-    return { headers, body };
-};
-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 = smithyClient._json(input);
-    body = context.utf8Decoder(JSON.stringify(body));
-    return { headers, body };
-};
-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 = smithyClient._json(input);
-    body = context.utf8Decoder(JSON.stringify(body));
-    return { headers, body };
-};
-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 = smithyClient._json(input);
-    body = context.utf8Decoder(JSON.stringify(body));
-    return { headers, body };
-};
-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 = smithyClient._json(input);
-    body = context.utf8Decoder(JSON.stringify(body));
-    return { headers, body };
-};
-const de_StartConversationResponseEventStream = (output, context) => {
-    return context.eventStreamMarshaller.deserialize(output, async (event) => {
-        if (event["PlaybackInterruptionEvent"] != null) {
-            return {
-                PlaybackInterruptionEvent: await de_PlaybackInterruptionEvent_event(event["PlaybackInterruptionEvent"], context),
-            };
-        }
-        if (event["TranscriptEvent"] != null) {
-            return {
-                TranscriptEvent: await de_TranscriptEvent_event(event["TranscriptEvent"], context),
-            };
-        }
-        if (event["IntentResultEvent"] != null) {
-            return {
-                IntentResultEvent: await de_IntentResultEvent_event(event["IntentResultEvent"], context),
-            };
-        }
-        if (event["TextResponseEvent"] != null) {
-            return {
-                TextResponseEvent: await de_TextResponseEvent_event(event["TextResponseEvent"], context),
-            };
-        }
-        if (event["AudioResponseEvent"] != null) {
-            return {
-                AudioResponseEvent: await de_AudioResponseEvent_event(event["AudioResponseEvent"], context),
-            };
-        }
-        if (event["HeartbeatEvent"] != null) {
-            return {
-                HeartbeatEvent: await de_HeartbeatEvent_event(event["HeartbeatEvent"], context),
-            };
-        }
-        if (event["AccessDeniedException"] != null) {
-            return {
-                AccessDeniedException: await de_AccessDeniedException_event(event["AccessDeniedException"], context),
-            };
-        }
-        if (event["ResourceNotFoundException"] != null) {
-            return {
-                ResourceNotFoundException: await de_ResourceNotFoundException_event(event["ResourceNotFoundException"], context),
-            };
-        }
-        if (event["ValidationException"] != null) {
-            return {
-                ValidationException: await de_ValidationException_event(event["ValidationException"], context),
-            };
-        }
-        if (event["ThrottlingException"] != null) {
-            return {
-                ThrottlingException: await de_ThrottlingException_event(event["ThrottlingException"], context),
-            };
-        }
-        if (event["InternalServerException"] != null) {
-            return {
-                InternalServerException: await de_InternalServerException_event(event["InternalServerException"], context),
-            };
-        }
-        if (event["ConflictException"] != null) {
-            return {
-                ConflictException: await de_ConflictException_event(event["ConflictException"], context),
-            };
-        }
-        if (event["DependencyFailedException"] != null) {
-            return {
-                DependencyFailedException: await de_DependencyFailedException_event(event["DependencyFailedException"], context),
-            };
-        }
-        if (event["BadGatewayException"] != null) {
-            return {
-                BadGatewayException: await de_BadGatewayException_event(event["BadGatewayException"], context),
-            };
-        }
-        return { $unknown: event };
-    });
-};
-const de_AccessDeniedException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_AccessDeniedExceptionRes(parsedOutput);
-};
-const de_AudioResponseEvent_event = async (output, context) => {
-    const contents = {};
-    const data = await core$1.parseJsonBody(output.body, context);
-    Object.assign(contents, de_AudioResponseEvent(data, context));
-    return contents;
-};
-const de_BadGatewayException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_BadGatewayExceptionRes(parsedOutput);
-};
-const de_ConflictException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_ConflictExceptionRes(parsedOutput);
-};
-const de_DependencyFailedException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_DependencyFailedExceptionRes(parsedOutput);
-};
-const de_HeartbeatEvent_event = async (output, context) => {
-    const contents = {};
-    const data = await core$1.parseJsonBody(output.body, context);
-    Object.assign(contents, smithyClient._json(data));
-    return contents;
-};
-const de_IntentResultEvent_event = async (output, context) => {
-    const contents = {};
-    const data = await core$1.parseJsonBody(output.body, context);
-    Object.assign(contents, de_IntentResultEvent(data));
-    return contents;
-};
-const de_InternalServerException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_InternalServerExceptionRes(parsedOutput);
-};
-const de_PlaybackInterruptionEvent_event = async (output, context) => {
-    const contents = {};
-    const data = await core$1.parseJsonBody(output.body, context);
-    Object.assign(contents, smithyClient._json(data));
-    return contents;
-};
-const de_ResourceNotFoundException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_ResourceNotFoundExceptionRes(parsedOutput);
-};
-const de_TextResponseEvent_event = async (output, context) => {
-    const contents = {};
-    const data = await core$1.parseJsonBody(output.body, context);
-    Object.assign(contents, smithyClient._json(data));
-    return contents;
-};
-const de_ThrottlingException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_ThrottlingExceptionRes(parsedOutput);
-};
-const de_TranscriptEvent_event = async (output, context) => {
-    const contents = {};
-    const data = await core$1.parseJsonBody(output.body, context);
-    Object.assign(contents, smithyClient._json(data));
-    return contents;
-};
-const de_ValidationException_event = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonBody(output.body, context),
-    };
-    return de_ValidationExceptionRes(parsedOutput);
-};
-const se_AudioInputEvent = (input, context) => {
-    return smithyClient.take(input, {
-        audioChunk: context.base64Encoder,
-        clientTimestampMillis: [],
-        contentType: [],
-        eventId: [],
-    });
-};
-const se_ConfigurationEvent = (input, context) => {
-    return smithyClient.take(input, {
-        clientTimestampMillis: [],
-        disablePlayback: [],
-        eventId: [],
-        requestAttributes: smithyClient._json,
-        responseContentType: [],
-        sessionState: (_) => se_SessionState(_),
-        welcomeMessages: smithyClient._json,
-    });
-};
-const se_DialogAction = (input, context) => {
-    return smithyClient.take(input, {
-        slotElicitationStyle: [],
-        slotToElicit: [],
-        subSlotToElicit: (_) => se_ElicitSubSlot(_),
-        type: [],
-    });
-};
-const se_ElicitSubSlot = (input, context) => {
-    return smithyClient.take(input, {
-        name: [],
-        subSlotToElicit: (_) => se_ElicitSubSlot(_),
-    });
-};
-const se_Intent = (input, context) => {
-    return smithyClient.take(input, {
-        confirmationState: [],
-        name: [],
-        slots: (_) => se_Slots(_),
-        state: [],
-    });
-};
-const se_RuntimeHintDetails = (input, context) => {
-    return smithyClient.take(input, {
-        runtimeHintValues: smithyClient._json,
-        subSlotHints: (_) => se_SlotHintsSlotMap(_),
-    });
-};
-const se_RuntimeHints = (input, context) => {
-    return smithyClient.take(input, {
-        slotHints: (_) => se_SlotHintsIntentMap(_),
-    });
-};
-const se_SessionState = (input, context) => {
-    return smithyClient.take(input, {
-        activeContexts: smithyClient._json,
-        dialogAction: (_) => se_DialogAction(_),
-        intent: (_) => se_Intent(_),
-        originatingRequestId: [],
-        runtimeHints: (_) => se_RuntimeHints(_),
-        sessionAttributes: smithyClient._json,
-    });
-};
-const se_Slot = (input, context) => {
-    return smithyClient.take(input, {
-        shape: [],
-        subSlots: (_) => se_Slots(_),
-        value: smithyClient._json,
-        values: (_) => se_Values(_),
-    });
-};
-const se_SlotHintsIntentMap = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = se_SlotHintsSlotMap(value);
-        return acc;
-    }, {});
-};
-const se_SlotHintsSlotMap = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = se_RuntimeHintDetails(value);
-        return acc;
-    }, {});
-};
-const se_Slots = (input, context) => {
-    return Object.entries(input).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = se_Slot(value);
-        return acc;
-    }, {});
-};
-const se_Values = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_Slot(entry);
-    });
-};
-const de_AudioResponseEvent = (output, context) => {
-    return smithyClient.take(output, {
-        audioChunk: context.base64Decoder,
-        contentType: smithyClient.expectString,
-        eventId: smithyClient.expectString,
-    });
-};
-const de_ConfidenceScore = (output, context) => {
-    return smithyClient.take(output, {
-        score: smithyClient.limitedParseDouble,
-    });
-};
-const de_DialogAction = (output, context) => {
-    return smithyClient.take(output, {
-        slotElicitationStyle: smithyClient.expectString,
-        slotToElicit: smithyClient.expectString,
-        subSlotToElicit: (_) => de_ElicitSubSlot(_),
-        type: smithyClient.expectString,
-    });
-};
-const de_ElicitSubSlot = (output, context) => {
-    return smithyClient.take(output, {
-        name: smithyClient.expectString,
-        subSlotToElicit: (_) => de_ElicitSubSlot(_),
-    });
-};
-const de_Intent = (output, context) => {
-    return smithyClient.take(output, {
-        confirmationState: smithyClient.expectString,
-        name: smithyClient.expectString,
-        slots: (_) => de_Slots(_),
-        state: smithyClient.expectString,
-    });
-};
-const de_IntentResultEvent = (output, context) => {
-    return smithyClient.take(output, {
-        eventId: smithyClient.expectString,
-        inputMode: smithyClient.expectString,
-        interpretations: (_) => de_Interpretations(_),
-        recognizedBotMember: smithyClient._json,
-        requestAttributes: smithyClient._json,
-        sessionId: smithyClient.expectString,
-        sessionState: (_) => de_SessionState(_),
-    });
-};
-const de_Interpretation = (output, context) => {
-    return smithyClient.take(output, {
-        intent: (_) => de_Intent(_),
-        interpretationSource: smithyClient.expectString,
-        nluConfidence: (_) => de_ConfidenceScore(_),
-        sentimentResponse: (_) => de_SentimentResponse(_),
-    });
-};
-const de_Interpretations = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Interpretation(entry);
-    });
-    return retVal;
-};
-const de_RuntimeHintDetails = (output, context) => {
-    return smithyClient.take(output, {
-        runtimeHintValues: smithyClient._json,
-        subSlotHints: (_) => de_SlotHintsSlotMap(_),
-    });
-};
-const de_RuntimeHints = (output, context) => {
-    return smithyClient.take(output, {
-        slotHints: (_) => de_SlotHintsIntentMap(_),
-    });
-};
-const de_SentimentResponse = (output, context) => {
-    return smithyClient.take(output, {
-        sentiment: smithyClient.expectString,
-        sentimentScore: (_) => de_SentimentScore(_),
-    });
-};
-const de_SentimentScore = (output, context) => {
-    return smithyClient.take(output, {
-        mixed: smithyClient.limitedParseDouble,
-        negative: smithyClient.limitedParseDouble,
-        neutral: smithyClient.limitedParseDouble,
-        positive: smithyClient.limitedParseDouble,
-    });
-};
-const de_SessionState = (output, context) => {
-    return smithyClient.take(output, {
-        activeContexts: smithyClient._json,
-        dialogAction: (_) => de_DialogAction(_),
-        intent: (_) => de_Intent(_),
-        originatingRequestId: smithyClient.expectString,
-        runtimeHints: (_) => de_RuntimeHints(_),
-        sessionAttributes: smithyClient._json,
-    });
-};
-const de_Slot = (output, context) => {
-    return smithyClient.take(output, {
-        shape: smithyClient.expectString,
-        subSlots: (_) => de_Slots(_),
-        value: smithyClient._json,
-        values: (_) => de_Values(_),
-    });
-};
-const de_SlotHintsIntentMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = de_SlotHintsSlotMap(value);
-        return acc;
-    }, {});
-};
-const de_SlotHintsSlotMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = de_RuntimeHintDetails(value);
-        return acc;
-    }, {});
-};
-const de_Slots = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = de_Slot(value);
-        return acc;
-    }, {});
-};
-const de_Values = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Slot(entry);
-    });
-    return retVal;
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
+const _AC = "ActiveContext";
+const _ACL = "ActiveContextsList";
+const _ACPM = "ActiveContextParametersMap";
+const _ACTTL = "ActiveContextTimeToLive";
+const _ADE = "AccessDeniedException";
+const _AIE = "AudioInputEvent";
+const _ARE = "AudioResponseEvent";
+const _B = "Button";
+const _BGE = "BadGatewayException";
+const _BL = "ButtonsList";
+const _BS = "BlobStream";
+const _CE = "ConfigurationEvent";
+const _CEo = "ConflictException";
+const _CS = "ConfidenceScore";
+const _CT = "Content-Type";
+const _DA = "DialogAction";
+const _DE = "DisconnectionEvent";
+const _DFE = "DependencyFailedException";
+const _DS = "DeleteSession";
+const _DSR = "DeleteSessionRequest";
+const _DSRe = "DeleteSessionResponse";
+const _DTMFIE = "DTMFInputEvent";
+const _DTMFR = "DTMFRegex";
+const _ESS = "ElicitSubSlot";
+const _GS = "GetSession";
+const _GSR = "GetSessionRequest";
+const _GSRe = "GetSessionResponse";
+const _HE = "HeartbeatEvent";
+const _I = "Intent";
+const _IRC = "ImageResponseCard";
+const _IRE = "IntentResultEvent";
+const _ISE = "InternalServerException";
+const _In = "Interpretation";
+const _Int = "Interpretations";
+const _M = "Message";
+const _Me = "Messages";
+const _PCE = "PlaybackCompletionEvent";
+const _PIE = "PlaybackInterruptionEvent";
+const _PS = "PutSession";
+const _PSR = "PutSessionRequest";
+const _PSRu = "PutSessionResponse";
+const _RBM = "RecognizedBotMember";
+const _RCT = "ResponseContentType";
+const _RCT_ = "Response-Content-Type";
+const _RH = "RuntimeHints";
+const _RHD = "RuntimeHintDetails";
+const _RHV = "RuntimeHintValue";
+const _RHVL = "RuntimeHintValuesList";
+const _RNFE = "ResourceNotFoundException";
+const _RT = "RecognizeText";
+const _RTR = "RecognizeTextRequest";
+const _RTRe = "RecognizeTextResponse";
+const _RU = "RecognizeUtterance";
+const _RUR = "RecognizeUtteranceRequest";
+const _RURe = "RecognizeUtteranceResponse";
+const _S = "Slot";
+const _SC = "StartConversation";
+const _SCR = "StartConversationRequest";
+const _SCRES = "StartConversationRequestEventStream";
+const _SCRESt = "StartConversationResponseEventStream";
+const _SCRt = "StartConversationResponse";
+const _SHIM = "SlotHintsIntentMap";
+const _SHSM = "SlotHintsSlotMap";
+const _SNES = "SensitiveNonEmptyString";
+const _SR = "SentimentResponse";
+const _SS = "SentimentScore";
+const _SSe = "SessionState";
+const _Sl = "Slots";
+const _T = "Text";
+const _TE = "ThrottlingException";
+const _TEr = "TranscriptEvent";
+const _TIE = "TextInputEvent";
+const _TRE = "TextResponseEvent";
+const _V = "Value";
+const _VE = "ValidationException";
+const _Va = "Values";
+const _aC = "audioChunk";
+const _aCc = "activeContexts";
+const _aS = "audioStream";
+const _b = "buttons";
+const _bAI = "botAliasId";
+const _bI = "botId";
+const _bN = "botName";
+const _c = "client";
+const _cA = "contextAttributes";
+const _cBEI = "causedByEventId";
 const _cM = "conversationMode";
+const _cS = "confirmationState";
 const _cT = "contentType";
-const _ct = "content-type";
+const _cTM = "clientTimestampMillis";
+const _co = "content";
+const _dA = "dialogAction";
+const _dP = "disablePlayback";
+const _e = "error";
+const _eI = "eventId";
+const _eR = "eventReason";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
 const _i = "interpretations";
+const _iC = "inputCharacter";
 const _iM = "inputMode";
+const _iRC = "imageResponseCard";
+const _iS = "interpretationSource";
+const _iSn = "inputStream";
 const _iT = "inputTranscript";
-const _m = "messages";
-const _r = "responsecontenttype";
+const _iU = "imageUrl";
+const _iV = "interpretedValue";
+const _in = "intent";
+const _lI = "localeId";
+const _m = "message";
+const _me = "messages";
+const _mi = "mixed";
+const _n = "name";
+const _nC = "nluConfidence";
+const _ne = "negative";
+const _neu = "neutral";
+const _oRI = "originatingRequestId";
+const _oV = "originalValue";
+const _p = "phrase";
+const _po = "positive";
 const _rA = "requestAttributes";
 const _rBM = "recognizedBotMember";
 const _rCT = "responseContentType";
 const _rCTe = "requestContentType";
-const _rct = "response-content-type";
+const _rES = "requestEventStream";
+const _rESe = "responseEventStream";
+const _rH = "runtimeHints";
+const _rHV = "runtimeHintValues";
+const _rV = "resolvedValues";
+const _s = "streaming";
+const _sA = "sessionAttributes";
+const _sES = "slotElicitationStyle";
+const _sH = "slotHints";
 const _sI = "sessionId";
+const _sR = "sentimentResponse";
 const _sS = "sessionState";
+const _sSH = "subSlotHints";
+const _sSTE = "subSlotToElicit";
+const _sSe = "sentimentScore";
+const _sSu = "subSlots";
+const _sTE = "slotToElicit";
+const _sc = "score";
+const _se = "server";
+const _sen = "sentiment";
+const _sh = "shape";
+const _sl = "slots";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.lexruntimev2";
+const _st = "state";
+const _su = "subtitle";
+const _t = "text";
+const _tTL = "timeToLive";
+const _tTLIS = "timeToLiveInSeconds";
+const _tTLu = "turnsToLive";
+const _ti = "title";
+const _tr = "transcript";
+const _ty = "type";
+const _v = "value";
+const _va = "values";
+const _wM = "welcomeMessages";
 const _xalcm = "x-amz-lex-conversation-mode";
 const _xali = "x-amz-lex-interpretations";
 const _xalim = "x-amz-lex-input-mode";
@@ -1314,21 +500,587 @@ const _xalra = "x-amz-lex-request-attributes";
 const _xalrbm = "x-amz-lex-recognized-bot-member";
 const _xalsi = "x-amz-lex-session-id";
 const _xalss = "x-amz-lex-session-state";
+const n0 = "com.amazonaws.lexruntimev2";
+var BlobStream = [
+    0,
+    n0,
+    _BS,
+    {
+        [_s]: 1,
+    },
+    42,
+];
+var DTMFRegex = [0, n0, _DTMFR, 8, 0];
+var SensitiveNonEmptyString = [0, n0, _SNES, 8, 0];
+var Text = [0, n0, _T, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var ActiveContext = [
+    3,
+    n0,
+    _AC,
+    0,
+    [_n, _tTL, _cA],
+    [0, () => ActiveContextTimeToLive, [() => ActiveContextParametersMap, 0]],
+];
+var ActiveContextTimeToLive = [3, n0, _ACTTL, 0, [_tTLIS, _tTLu], [1, 1]];
+var AudioInputEvent = [3, n0, _AIE, 0, [_aC, _cT, _eI, _cTM], [21, 0, 0, 1]];
+var AudioResponseEvent = [3, n0, _ARE, 0, [_aC, _cT, _eI], [21, 0, 0]];
+var BadGatewayException = [
+    -3,
+    n0,
+    _BGE,
+    {
+        [_e]: _se,
+        [_hE]: 502,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(BadGatewayException, BadGatewayException$1);
+var Button = [3, n0, _B, 0, [_t, _v], [0, 0]];
+var ConfidenceScore = [3, n0, _CS, 0, [_sc], [1]];
+var ConfigurationEvent = [
+    3,
+    n0,
+    _CE,
+    0,
+    [_rA, _rCT, _sS, _wM, _dP, _eI, _cTM],
+    [128 | 0, 0, [() => SessionState, 0], [() => Messages, 0], 2, 0, 1],
+];
+var ConflictException = [
+    -3,
+    n0,
+    _CEo,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var DeleteSessionRequest = [
+    3,
+    n0,
+    _DSR,
+    0,
+    [_bI, _bAI, _lI, _sI],
+    [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ],
+];
+var DeleteSessionResponse = [3, n0, _DSRe, 0, [_bI, _bAI, _lI, _sI], [0, 0, 0, 0]];
+var DependencyFailedException = [
+    -3,
+    n0,
+    _DFE,
+    {
+        [_e]: _c,
+        [_hE]: 424,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(DependencyFailedException, DependencyFailedException$1);
+var DialogAction = [
+    3,
+    n0,
+    _DA,
+    0,
+    [_ty, _sTE, _sES, _sSTE],
+    [0, 0, 0, () => ElicitSubSlot],
+];
+var DisconnectionEvent = [3, n0, _DE, 0, [_eI, _cTM], [0, 1]];
+var DTMFInputEvent = [3, n0, _DTMFIE, 0, [_iC, _eI, _cTM], [[() => DTMFRegex, 0], 0, 1]];
+var ElicitSubSlot = [3, n0, _ESS, 0, [_n, _sSTE], [0, () => ElicitSubSlot]];
+var GetSessionRequest = [
+    3,
+    n0,
+    _GSR,
+    0,
+    [_bI, _bAI, _lI, _sI],
+    [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ],
+];
+var GetSessionResponse = [
+    3,
+    n0,
+    _GSRe,
+    0,
+    [_sI, _me, _i, _sS],
+    [0, [() => Messages, 0], () => Interpretations, [() => SessionState, 0]],
+];
+var HeartbeatEvent = [3, n0, _HE, 0, [_eI], [0]];
+var ImageResponseCard = [
+    3,
+    n0,
+    _IRC,
+    0,
+    [_ti, _su, _iU, _b],
+    [0, 0, 0, () => ButtonsList],
+];
+var Intent = [3, n0, _I, 0, [_n, _sl, _st, _cS], [0, () => Slots, 0, 0]];
+var IntentResultEvent = [
+    3,
+    n0,
+    _IRE,
+    0,
+    [_iM, _i, _sS, _rA, _sI, _eI, _rBM],
+    [0, () => Interpretations, [() => SessionState, 0], 128 | 0, 0, 0, () => RecognizedBotMember],
+];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var Interpretation = [
+    3,
+    n0,
+    _In,
+    0,
+    [_nC, _sR, _in, _iS],
+    [() => ConfidenceScore, () => SentimentResponse, () => Intent, 0],
+];
+var Message = [
+    3,
+    n0,
+    _M,
+    0,
+    [_co, _cT, _iRC],
+    [[() => Text, 0], 0, () => ImageResponseCard],
+];
+var PlaybackCompletionEvent = [3, n0, _PCE, 0, [_eI, _cTM], [0, 1]];
+var PlaybackInterruptionEvent = [3, n0, _PIE, 0, [_eR, _cBEI, _eI], [0, 0, 0]];
+var PutSessionRequest = [
+    3,
+    n0,
+    _PSR,
+    0,
+    [_bI, _bAI, _lI, _sI, _me, _sS, _rA, _rCT],
+    [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [() => Messages, 0],
+        [() => SessionState, 0],
+        128 | 0,
+        [
+            0,
+            {
+                [_hH]: _RCT,
+            },
+        ],
+    ],
+];
+var PutSessionResponse = [
+    3,
+    n0,
+    _PSRu,
+    0,
+    [_cT, _me, _sS, _rA, _sI, _aS],
+    [
+        [
+            0,
+            {
+                [_hH]: _CT,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xalm,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xalss,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xalra,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xalsi,
+            },
+        ],
+        [() => BlobStream, 16],
+    ],
+];
+var RecognizedBotMember = [3, n0, _RBM, 0, [_bI, _bN], [0, 0]];
+var RecognizeTextRequest = [
+    3,
+    n0,
+    _RTR,
+    0,
+    [_bI, _bAI, _lI, _sI, _t, _sS, _rA],
+    [[0, 1], [0, 1], [0, 1], [0, 1], [() => Text, 0], [() => SessionState, 0], 128 | 0],
+];
+var RecognizeTextResponse = [
+    3,
+    n0,
+    _RTRe,
+    0,
+    [_me, _sS, _i, _rA, _sI, _rBM],
+    [[() => Messages, 0], [() => SessionState, 0], () => Interpretations, 128 | 0, 0, () => RecognizedBotMember],
+];
+var RecognizeUtteranceRequest = [
+    3,
+    n0,
+    _RUR,
+    0,
+    [_bI, _bAI, _lI, _sI, _sS, _rA, _rCTe, _rCT, _iSn],
+    [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [
+            () => SensitiveNonEmptyString,
+            {
+                [_hH]: _xalss,
+            },
+        ],
+        [
+            () => SensitiveNonEmptyString,
+            {
+                [_hH]: _xalra,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CT,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _RCT_,
+            },
+        ],
+        [() => BlobStream, 16],
+    ],
+];
+var RecognizeUtteranceResponse = [
+    3,
+    n0,
+    _RURe,
+    0,
+    [_iM, _cT, _me, _i, _sS, _rA, _sI, _iT, _aS, _rBM],
+    [
+        [
+            0,
+            {
+                [_hH]: _xalim,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _CT,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xalm,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xali,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xalss,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xalra,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xalsi,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xalit,
+            },
+        ],
+        [() => BlobStream, 16],
+        [
+            0,
+            {
+                [_hH]: _xalrbm,
+            },
+        ],
+    ],
+];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var RuntimeHintDetails = [
+    3,
+    n0,
+    _RHD,
+    0,
+    [_rHV, _sSH],
+    [() => RuntimeHintValuesList, () => SlotHintsSlotMap],
+];
+var RuntimeHints = [3, n0, _RH, 0, [_sH], [() => SlotHintsIntentMap]];
+var RuntimeHintValue = [3, n0, _RHV, 0, [_p], [0]];
+var SentimentResponse = [3, n0, _SR, 0, [_sen, _sSe], [0, () => SentimentScore]];
+var SentimentScore = [3, n0, _SS, 0, [_po, _ne, _neu, _mi], [1, 1, 1, 1]];
+var SessionState = [
+    3,
+    n0,
+    _SSe,
+    0,
+    [_dA, _in, _aCc, _sA, _oRI, _rH],
+    [() => DialogAction, () => Intent, [() => ActiveContextsList, 0], 128 | 0, 0, () => RuntimeHints],
+];
+var Slot = [
+    3,
+    n0,
+    _S,
+    0,
+    [_v, _sh, _va, _sSu],
+    [() => Value, 0, () => Values, () => Slots],
+];
+var StartConversationRequest = [
+    3,
+    n0,
+    _SCR,
+    0,
+    [_bI, _bAI, _lI, _sI, _cM, _rES],
+    [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [
+            0,
+            {
+                [_hH]: _xalcm,
+            },
+        ],
+        [() => StartConversationRequestEventStream, 16],
+    ],
+];
+var StartConversationResponse = [
+    3,
+    n0,
+    _SCRt,
+    0,
+    [_rESe],
+    [[() => StartConversationResponseEventStream, 16]],
+];
+var TextInputEvent = [3, n0, _TIE, 0, [_t, _eI, _cTM], [[() => Text, 0], 0, 1]];
+var TextResponseEvent = [3, n0, _TRE, 0, [_me, _eI], [[() => Messages, 0], 0]];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var TranscriptEvent = [3, n0, _TEr, 0, [_tr, _eI], [0, 0]];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var Value = [3, n0, _V, 0, [_oV, _iV, _rV], [0, 0, 64 | 0]];
+var LexRuntimeV2ServiceException = [-3, _sm, "LexRuntimeV2ServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(LexRuntimeV2ServiceException, LexRuntimeV2ServiceException$1);
+var ActiveContextsList = [1, n0, _ACL, 0, [() => ActiveContext, 0]];
+var ButtonsList = [1, n0, _BL, 0, () => Button];
+var Interpretations = [1, n0, _Int, 0, () => Interpretation];
+var Messages = [1, n0, _Me, 0, [() => Message, 0]];
+var RuntimeHintValuesList = [1, n0, _RHVL, 0, () => RuntimeHintValue];
+var Values = [1, n0, _Va, 0, () => Slot];
+var ActiveContextParametersMap = [2, n0, _ACPM, 0, [0, 0], [() => Text, 0]];
+var SlotHintsIntentMap = [2, n0, _SHIM, 0, 0, () => SlotHintsSlotMap];
+var SlotHintsSlotMap = [2, n0, _SHSM, 0, 0, () => RuntimeHintDetails];
+var Slots = [2, n0, _Sl, 0, 0, () => Slot];
+var StartConversationRequestEventStream = [
+    3,
+    n0,
+    _SCRES,
+    {
+        [_s]: 1,
+    },
+    [_CE, _AIE, _DTMFIE, _TIE, _PCE, _DE],
+    [
+        [() => ConfigurationEvent, 0],
+        () => AudioInputEvent,
+        [() => DTMFInputEvent, 0],
+        [() => TextInputEvent, 0],
+        () => PlaybackCompletionEvent,
+        () => DisconnectionEvent,
+    ],
+];
+var StartConversationResponseEventStream = [
+    3,
+    n0,
+    _SCRESt,
+    {
+        [_s]: 1,
+    },
+    [_PIE, _TEr, _IRE, _TRE, _ARE, _HE, _ADE, _RNFE, _VE, _TE, _ISE, _CEo, _DFE, _BGE],
+    [
+        () => PlaybackInterruptionEvent,
+        () => TranscriptEvent,
+        [() => IntentResultEvent, 0],
+        [() => TextResponseEvent, 0],
+        () => AudioResponseEvent,
+        () => HeartbeatEvent,
+        [() => AccessDeniedException, 0],
+        [() => ResourceNotFoundException, 0],
+        [() => ValidationException, 0],
+        [() => ThrottlingException, 0],
+        [() => InternalServerException, 0],
+        [() => ConflictException, 0],
+        [() => DependencyFailedException, 0],
+        [() => BadGatewayException, 0],
+    ],
+];
+var DeleteSession = [
+    9,
+    n0,
+    _DS,
+    {
+        [_h]: ["DELETE", "/bots/{botId}/botAliases/{botAliasId}/botLocales/{localeId}/sessions/{sessionId}", 200],
+    },
+    () => DeleteSessionRequest,
+    () => DeleteSessionResponse,
+];
+var GetSession = [
+    9,
+    n0,
+    _GS,
+    {
+        [_h]: ["GET", "/bots/{botId}/botAliases/{botAliasId}/botLocales/{localeId}/sessions/{sessionId}", 200],
+    },
+    () => GetSessionRequest,
+    () => GetSessionResponse,
+];
+var PutSession = [
+    9,
+    n0,
+    _PS,
+    {
+        [_h]: ["POST", "/bots/{botId}/botAliases/{botAliasId}/botLocales/{localeId}/sessions/{sessionId}", 200],
+    },
+    () => PutSessionRequest,
+    () => PutSessionResponse,
+];
+var RecognizeText = [
+    9,
+    n0,
+    _RT,
+    {
+        [_h]: ["POST", "/bots/{botId}/botAliases/{botAliasId}/botLocales/{localeId}/sessions/{sessionId}/text", 200],
+    },
+    () => RecognizeTextRequest,
+    () => RecognizeTextResponse,
+];
+var RecognizeUtterance = [
+    9,
+    n0,
+    _RU,
+    {
+        [_h]: ["POST", "/bots/{botId}/botAliases/{botAliasId}/botLocales/{localeId}/sessions/{sessionId}/utterance", 200],
+    },
+    () => RecognizeUtteranceRequest,
+    () => RecognizeUtteranceResponse,
+];
+var StartConversation = [
+    9,
+    n0,
+    _SC,
+    {
+        [_h]: [
+            "POST",
+            "/bots/{botId}/botAliases/{botAliasId}/botLocales/{localeId}/sessions/{sessionId}/conversation",
+            200,
+        ],
+    },
+    () => StartConversationRequest,
+    () => StartConversationResponse,
+];
 
 class DeleteSessionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSDeepSenseRunTimeServiceApi2_0", "DeleteSession", {})
     .n("LexRuntimeV2Client", "DeleteSessionCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteSessionCommand)
-    .de(de_DeleteSessionCommand)
+    .sc(DeleteSession)
     .build() {
 }
 
@@ -1336,16 +1088,11 @@ class GetSessionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSDeepSenseRunTimeServiceApi2_0", "GetSession", {})
     .n("LexRuntimeV2Client", "GetSessionCommand")
-    .f(void 0, GetSessionResponseFilterSensitiveLog)
-    .ser(se_GetSessionCommand)
-    .de(de_GetSessionCommand)
+    .sc(GetSession)
     .build() {
 }
 
@@ -1353,16 +1100,11 @@ class PutSessionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSDeepSenseRunTimeServiceApi2_0", "PutSession", {})
     .n("LexRuntimeV2Client", "PutSessionCommand")
-    .f(PutSessionRequestFilterSensitiveLog, PutSessionResponseFilterSensitiveLog)
-    .ser(se_PutSessionCommand)
-    .de(de_PutSessionCommand)
+    .sc(PutSession)
     .build() {
 }
 
@@ -1370,16 +1112,11 @@ class RecognizeTextCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSDeepSenseRunTimeServiceApi2_0", "RecognizeText", {})
     .n("LexRuntimeV2Client", "RecognizeTextCommand")
-    .f(RecognizeTextRequestFilterSensitiveLog, RecognizeTextResponseFilterSensitiveLog)
-    .ser(se_RecognizeTextCommand)
-    .de(de_RecognizeTextCommand)
+    .sc(RecognizeText)
     .build() {
 }
 
@@ -1387,16 +1124,11 @@ class RecognizeUtteranceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSDeepSenseRunTimeServiceApi2_0", "RecognizeUtterance", {})
     .n("LexRuntimeV2Client", "RecognizeUtteranceCommand")
-    .f(RecognizeUtteranceRequestFilterSensitiveLog, RecognizeUtteranceResponseFilterSensitiveLog)
-    .ser(se_RecognizeUtteranceCommand)
-    .de(de_RecognizeUtteranceCommand)
+    .sc(RecognizeUtterance)
     .build() {
 }
 
@@ -1404,11 +1136,7 @@ class StartConversationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-        middlewareEventstream.getEventStreamPlugin(config),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()), middlewareEventstream.getEventStreamPlugin(config)];
 })
     .s("AWSDeepSenseRunTimeServiceApi2_0", "StartConversation", {
     eventStream: {
@@ -1417,9 +1145,7 @@ class StartConversationCommand extends smithyClient.Command
     },
 })
     .n("LexRuntimeV2Client", "StartConversationCommand")
-    .f(StartConversationRequestFilterSensitiveLog, StartConversationResponseFilterSensitiveLog)
-    .ser(se_StartConversationCommand)
-    .de(de_StartConversationCommand)
+    .sc(StartConversation)
     .build() {
 }
 
@@ -1443,50 +1169,31 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
-exports.ActiveContextFilterSensitiveLog = ActiveContextFilterSensitiveLog;
-exports.BadGatewayException = BadGatewayException;
-exports.ConfigurationEventFilterSensitiveLog = ConfigurationEventFilterSensitiveLog;
+exports.AccessDeniedException = AccessDeniedException$1;
+exports.BadGatewayException = BadGatewayException$1;
 exports.ConfirmationState = ConfirmationState;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.ConversationMode = ConversationMode;
-exports.DTMFInputEventFilterSensitiveLog = DTMFInputEventFilterSensitiveLog;
 exports.DeleteSessionCommand = DeleteSessionCommand;
-exports.DependencyFailedException = DependencyFailedException;
+exports.DependencyFailedException = DependencyFailedException$1;
 exports.DialogActionType = DialogActionType;
 exports.GetSessionCommand = GetSessionCommand;
-exports.GetSessionResponseFilterSensitiveLog = GetSessionResponseFilterSensitiveLog;
 exports.InputMode = InputMode;
-exports.IntentResultEventFilterSensitiveLog = IntentResultEventFilterSensitiveLog;
 exports.IntentState = IntentState;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.InterpretationSource = InterpretationSource;
 exports.LexRuntimeV2 = LexRuntimeV2;
 exports.LexRuntimeV2Client = LexRuntimeV2Client;
-exports.LexRuntimeV2ServiceException = LexRuntimeV2ServiceException;
+exports.LexRuntimeV2ServiceException = LexRuntimeV2ServiceException$1;
 exports.MessageContentType = MessageContentType;
-exports.MessageFilterSensitiveLog = MessageFilterSensitiveLog;
 exports.PlaybackInterruptionReason = PlaybackInterruptionReason;
 exports.PutSessionCommand = PutSessionCommand;
-exports.PutSessionRequestFilterSensitiveLog = PutSessionRequestFilterSensitiveLog;
-exports.PutSessionResponseFilterSensitiveLog = PutSessionResponseFilterSensitiveLog;
 exports.RecognizeTextCommand = RecognizeTextCommand;
-exports.RecognizeTextRequestFilterSensitiveLog = RecognizeTextRequestFilterSensitiveLog;
-exports.RecognizeTextResponseFilterSensitiveLog = RecognizeTextResponseFilterSensitiveLog;
 exports.RecognizeUtteranceCommand = RecognizeUtteranceCommand;
-exports.RecognizeUtteranceRequestFilterSensitiveLog = RecognizeUtteranceRequestFilterSensitiveLog;
-exports.RecognizeUtteranceResponseFilterSensitiveLog = RecognizeUtteranceResponseFilterSensitiveLog;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.SentimentType = SentimentType;
-exports.SessionStateFilterSensitiveLog = SessionStateFilterSensitiveLog;
 exports.Shape = Shape;
 exports.StartConversationCommand = StartConversationCommand;
-exports.StartConversationRequestEventStreamFilterSensitiveLog = StartConversationRequestEventStreamFilterSensitiveLog;
-exports.StartConversationRequestFilterSensitiveLog = StartConversationRequestFilterSensitiveLog;
-exports.StartConversationResponseEventStreamFilterSensitiveLog = StartConversationResponseEventStreamFilterSensitiveLog;
-exports.StartConversationResponseFilterSensitiveLog = StartConversationResponseFilterSensitiveLog;
 exports.StyleType = StyleType;
-exports.TextInputEventFilterSensitiveLog = TextInputEventFilterSensitiveLog;
-exports.TextResponseEventFilterSensitiveLog = TextResponseEventFilterSensitiveLog;
-exports.ThrottlingException = ThrottlingException;
-exports.ValidationException = ValidationException;
+exports.ThrottlingException = ThrottlingException$1;
+exports.ValidationException = ValidationException$1;