@aws-sdk/client-lex-runtime-v2 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,11 +1,1831 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LexRuntimeV2ServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./LexRuntimeV2Client"), exports);
-tslib_1.__exportStar(require("./LexRuntimeV2"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var LexRuntimeV2ServiceException_1 = require("./models/LexRuntimeV2ServiceException");
-Object.defineProperty(exports, "LexRuntimeV2ServiceException", { enumerable: true, get: function () { return LexRuntimeV2ServiceException_1.LexRuntimeV2ServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AccessDeniedException: () => AccessDeniedException,
+  ActiveContextFilterSensitiveLog: () => ActiveContextFilterSensitiveLog,
+  BadGatewayException: () => BadGatewayException,
+  ConfigurationEventFilterSensitiveLog: () => ConfigurationEventFilterSensitiveLog,
+  ConfirmationState: () => ConfirmationState,
+  ConflictException: () => ConflictException,
+  ConversationMode: () => ConversationMode,
+  DTMFInputEventFilterSensitiveLog: () => DTMFInputEventFilterSensitiveLog,
+  DeleteSessionCommand: () => DeleteSessionCommand,
+  DependencyFailedException: () => DependencyFailedException,
+  DialogActionType: () => DialogActionType,
+  GetSessionCommand: () => GetSessionCommand,
+  GetSessionResponseFilterSensitiveLog: () => GetSessionResponseFilterSensitiveLog,
+  InputMode: () => InputMode,
+  IntentResultEventFilterSensitiveLog: () => IntentResultEventFilterSensitiveLog,
+  IntentState: () => IntentState,
+  InternalServerException: () => InternalServerException,
+  InterpretationSource: () => InterpretationSource,
+  LexRuntimeV2: () => LexRuntimeV2,
+  LexRuntimeV2Client: () => LexRuntimeV2Client,
+  LexRuntimeV2ServiceException: () => LexRuntimeV2ServiceException,
+  MessageContentType: () => MessageContentType,
+  MessageFilterSensitiveLog: () => MessageFilterSensitiveLog,
+  PlaybackInterruptionReason: () => PlaybackInterruptionReason,
+  PutSessionCommand: () => PutSessionCommand,
+  PutSessionRequestFilterSensitiveLog: () => PutSessionRequestFilterSensitiveLog,
+  PutSessionResponseFilterSensitiveLog: () => PutSessionResponseFilterSensitiveLog,
+  RecognizeTextCommand: () => RecognizeTextCommand,
+  RecognizeTextRequestFilterSensitiveLog: () => RecognizeTextRequestFilterSensitiveLog,
+  RecognizeTextResponseFilterSensitiveLog: () => RecognizeTextResponseFilterSensitiveLog,
+  RecognizeUtteranceCommand: () => RecognizeUtteranceCommand,
+  RecognizeUtteranceRequestFilterSensitiveLog: () => RecognizeUtteranceRequestFilterSensitiveLog,
+  RecognizeUtteranceResponseFilterSensitiveLog: () => RecognizeUtteranceResponseFilterSensitiveLog,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  SentimentType: () => SentimentType,
+  SessionStateFilterSensitiveLog: () => SessionStateFilterSensitiveLog,
+  Shape: () => Shape,
+  StartConversationCommand: () => StartConversationCommand,
+  StartConversationRequestEventStream: () => StartConversationRequestEventStream,
+  StartConversationRequestEventStreamFilterSensitiveLog: () => StartConversationRequestEventStreamFilterSensitiveLog,
+  StartConversationRequestFilterSensitiveLog: () => StartConversationRequestFilterSensitiveLog,
+  StartConversationResponseEventStream: () => StartConversationResponseEventStream,
+  StartConversationResponseEventStreamFilterSensitiveLog: () => StartConversationResponseEventStreamFilterSensitiveLog,
+  StartConversationResponseFilterSensitiveLog: () => StartConversationResponseFilterSensitiveLog,
+  StyleType: () => StyleType,
+  TextInputEventFilterSensitiveLog: () => TextInputEventFilterSensitiveLog,
+  TextResponseEventFilterSensitiveLog: () => TextResponseEventFilterSensitiveLog,
+  ThrottlingException: () => ThrottlingException,
+  ValidationException: () => ValidationException,
+  __Client: () => import_smithy_client.Client
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/LexRuntimeV2Client.ts
+var import_middleware_eventstream = require("@aws-sdk/middleware-eventstream");
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_eventstream_serde_config_resolver = require("@smithy/eventstream-serde-config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "lex"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/LexRuntimeV2Client.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/LexRuntimeV2Client.ts
+var _LexRuntimeV2Client = class _LexRuntimeV2Client extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_eventstream.resolveEventStreamConfig)(_config_6);
+    const _config_8 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_7);
+    const _config_9 = (0, import_eventstream_serde_config_resolver.resolveEventStreamSerdeConfig)(_config_8);
+    const _config_10 = resolveRuntimeExtensions(_config_9, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_10);
+    this.config = _config_10;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_LexRuntimeV2Client, "LexRuntimeV2Client");
+var LexRuntimeV2Client = _LexRuntimeV2Client;
+
+// src/LexRuntimeV2.ts
+
+
+// src/commands/DeleteSessionCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@smithy/core");
+
+
+// src/models/LexRuntimeV2ServiceException.ts
+
+var _LexRuntimeV2ServiceException = class _LexRuntimeV2ServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _LexRuntimeV2ServiceException.prototype);
+  }
+};
+__name(_LexRuntimeV2ServiceException, "LexRuntimeV2ServiceException");
+var LexRuntimeV2ServiceException = _LexRuntimeV2ServiceException;
+
+// src/models/models_0.ts
+
+var _AccessDeniedException = class _AccessDeniedException extends LexRuntimeV2ServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var _ConflictException = class _ConflictException extends LexRuntimeV2ServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _InternalServerException = class _InternalServerException extends LexRuntimeV2ServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends LexRuntimeV2ServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _ThrottlingException = class _ThrottlingException extends LexRuntimeV2ServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var _ValidationException = class _ValidationException extends LexRuntimeV2ServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var ConfirmationState = {
+  CONFIRMED: "Confirmed",
+  DENIED: "Denied",
+  NONE: "None"
+};
+var Shape = {
+  COMPOSITE: "Composite",
+  LIST: "List",
+  SCALAR: "Scalar"
+};
+var IntentState = {
+  FAILED: "Failed",
+  FULFILLED: "Fulfilled",
+  FULFILLMENT_IN_PROGRESS: "FulfillmentInProgress",
+  IN_PROGRESS: "InProgress",
+  READY_FOR_FULFILLMENT: "ReadyForFulfillment",
+  WAITING: "Waiting"
+};
+var InterpretationSource = {
+  BEDROCK: "Bedrock",
+  LEX: "Lex"
+};
+var SentimentType = {
+  MIXED: "MIXED",
+  NEGATIVE: "NEGATIVE",
+  NEUTRAL: "NEUTRAL",
+  POSITIVE: "POSITIVE"
+};
+var MessageContentType = {
+  CUSTOM_PAYLOAD: "CustomPayload",
+  IMAGE_RESPONSE_CARD: "ImageResponseCard",
+  PLAIN_TEXT: "PlainText",
+  SSML: "SSML"
+};
+var StyleType = {
+  DEFAULT: "Default",
+  SPELL_BY_LETTER: "SpellByLetter",
+  SPELL_BY_WORD: "SpellByWord"
+};
+var DialogActionType = {
+  CLOSE: "Close",
+  CONFIRM_INTENT: "ConfirmIntent",
+  DELEGATE: "Delegate",
+  ELICIT_INTENT: "ElicitIntent",
+  ELICIT_SLOT: "ElicitSlot",
+  NONE: "None"
+};
+var _BadGatewayException = class _BadGatewayException extends LexRuntimeV2ServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "BadGatewayException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "BadGatewayException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _BadGatewayException.prototype);
+  }
+};
+__name(_BadGatewayException, "BadGatewayException");
+var BadGatewayException = _BadGatewayException;
+var _DependencyFailedException = class _DependencyFailedException extends LexRuntimeV2ServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DependencyFailedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DependencyFailedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DependencyFailedException.prototype);
+  }
+};
+__name(_DependencyFailedException, "DependencyFailedException");
+var DependencyFailedException = _DependencyFailedException;
+var ConversationMode = {
+  AUDIO: "AUDIO",
+  TEXT: "TEXT"
+};
+var InputMode = {
+  DTMF: "DTMF",
+  SPEECH: "Speech",
+  TEXT: "Text"
+};
+var PlaybackInterruptionReason = {
+  DTMF_START_DETECTED: "DTMF_START_DETECTED",
+  TEXT_DETECTED: "TEXT_DETECTED",
+  VOICE_START_DETECTED: "VOICE_START_DETECTED"
+};
+var StartConversationRequestEventStream;
+((StartConversationRequestEventStream2) => {
+  StartConversationRequestEventStream2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.ConfigurationEvent !== void 0)
+      return visitor.ConfigurationEvent(value.ConfigurationEvent);
+    if (value.AudioInputEvent !== void 0)
+      return visitor.AudioInputEvent(value.AudioInputEvent);
+    if (value.DTMFInputEvent !== void 0)
+      return visitor.DTMFInputEvent(value.DTMFInputEvent);
+    if (value.TextInputEvent !== void 0)
+      return visitor.TextInputEvent(value.TextInputEvent);
+    if (value.PlaybackCompletionEvent !== void 0)
+      return visitor.PlaybackCompletionEvent(value.PlaybackCompletionEvent);
+    if (value.DisconnectionEvent !== void 0)
+      return visitor.DisconnectionEvent(value.DisconnectionEvent);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(StartConversationRequestEventStream || (StartConversationRequestEventStream = {}));
+var StartConversationResponseEventStream;
+((StartConversationResponseEventStream3) => {
+  StartConversationResponseEventStream3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.PlaybackInterruptionEvent !== void 0)
+      return visitor.PlaybackInterruptionEvent(value.PlaybackInterruptionEvent);
+    if (value.TranscriptEvent !== void 0)
+      return visitor.TranscriptEvent(value.TranscriptEvent);
+    if (value.IntentResultEvent !== void 0)
+      return visitor.IntentResultEvent(value.IntentResultEvent);
+    if (value.TextResponseEvent !== void 0)
+      return visitor.TextResponseEvent(value.TextResponseEvent);
+    if (value.AudioResponseEvent !== void 0)
+      return visitor.AudioResponseEvent(value.AudioResponseEvent);
+    if (value.HeartbeatEvent !== void 0)
+      return visitor.HeartbeatEvent(value.HeartbeatEvent);
+    if (value.AccessDeniedException !== void 0)
+      return visitor.AccessDeniedException(value.AccessDeniedException);
+    if (value.ResourceNotFoundException !== void 0)
+      return visitor.ResourceNotFoundException(value.ResourceNotFoundException);
+    if (value.ValidationException !== void 0)
+      return visitor.ValidationException(value.ValidationException);
+    if (value.ThrottlingException !== void 0)
+      return visitor.ThrottlingException(value.ThrottlingException);
+    if (value.InternalServerException !== void 0)
+      return visitor.InternalServerException(value.InternalServerException);
+    if (value.ConflictException !== void 0)
+      return visitor.ConflictException(value.ConflictException);
+    if (value.DependencyFailedException !== void 0)
+      return visitor.DependencyFailedException(value.DependencyFailedException);
+    if (value.BadGatewayException !== void 0)
+      return visitor.BadGatewayException(value.BadGatewayException);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(StartConversationResponseEventStream || (StartConversationResponseEventStream = {}));
+var ActiveContextFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.contextAttributes && { contextAttributes: import_smithy_client.SENSITIVE_STRING }
+}), "ActiveContextFilterSensitiveLog");
+var MessageFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.content && { content: import_smithy_client.SENSITIVE_STRING }
+}), "MessageFilterSensitiveLog");
+var PutSessionResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "PutSessionResponseFilterSensitiveLog");
+var RecognizeUtteranceRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.sessionState && { sessionState: import_smithy_client.SENSITIVE_STRING },
+  ...obj.requestAttributes && { requestAttributes: import_smithy_client.SENSITIVE_STRING }
+}), "RecognizeUtteranceRequestFilterSensitiveLog");
+var RecognizeUtteranceResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "RecognizeUtteranceResponseFilterSensitiveLog");
+var DTMFInputEventFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.inputCharacter && { inputCharacter: import_smithy_client.SENSITIVE_STRING }
+}), "DTMFInputEventFilterSensitiveLog");
+var TextInputEventFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.text && { text: import_smithy_client.SENSITIVE_STRING }
+}), "TextInputEventFilterSensitiveLog");
+var TextResponseEventFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.messages && { messages: obj.messages.map((item) => MessageFilterSensitiveLog(item)) }
+}), "TextResponseEventFilterSensitiveLog");
+var SessionStateFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.activeContexts && {
+    activeContexts: obj.activeContexts.map((item) => ActiveContextFilterSensitiveLog(item))
+  }
+}), "SessionStateFilterSensitiveLog");
+var ConfigurationEventFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.welcomeMessages && { welcomeMessages: obj.welcomeMessages.map((item) => MessageFilterSensitiveLog(item)) }
+}), "ConfigurationEventFilterSensitiveLog");
+var PutSessionRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.messages && { messages: obj.messages.map((item) => MessageFilterSensitiveLog(item)) }
+}), "PutSessionRequestFilterSensitiveLog");
+var RecognizeTextRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.text && { text: import_smithy_client.SENSITIVE_STRING }
+}), "RecognizeTextRequestFilterSensitiveLog");
+var StartConversationRequestEventStreamFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.ConfigurationEvent !== void 0)
+    return { ConfigurationEvent: ConfigurationEventFilterSensitiveLog(obj.ConfigurationEvent) };
+  if (obj.AudioInputEvent !== void 0)
+    return { AudioInputEvent: obj.AudioInputEvent };
+  if (obj.DTMFInputEvent !== void 0)
+    return { DTMFInputEvent: DTMFInputEventFilterSensitiveLog(obj.DTMFInputEvent) };
+  if (obj.TextInputEvent !== void 0)
+    return { TextInputEvent: TextInputEventFilterSensitiveLog(obj.TextInputEvent) };
+  if (obj.PlaybackCompletionEvent !== void 0)
+    return { PlaybackCompletionEvent: obj.PlaybackCompletionEvent };
+  if (obj.DisconnectionEvent !== void 0)
+    return { DisconnectionEvent: obj.DisconnectionEvent };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "StartConversationRequestEventStreamFilterSensitiveLog");
+var StartConversationRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.requestEventStream && { requestEventStream: "STREAMING_CONTENT" }
+}), "StartConversationRequestFilterSensitiveLog");
+var GetSessionResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.messages && { messages: obj.messages.map((item) => MessageFilterSensitiveLog(item)) }
+}), "GetSessionResponseFilterSensitiveLog");
+var IntentResultEventFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "IntentResultEventFilterSensitiveLog");
+var RecognizeTextResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.messages && { messages: obj.messages.map((item) => MessageFilterSensitiveLog(item)) }
+}), "RecognizeTextResponseFilterSensitiveLog");
+var StartConversationResponseEventStreamFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.PlaybackInterruptionEvent !== void 0)
+    return { PlaybackInterruptionEvent: obj.PlaybackInterruptionEvent };
+  if (obj.TranscriptEvent !== void 0)
+    return { TranscriptEvent: obj.TranscriptEvent };
+  if (obj.IntentResultEvent !== void 0)
+    return { IntentResultEvent: IntentResultEventFilterSensitiveLog(obj.IntentResultEvent) };
+  if (obj.TextResponseEvent !== void 0)
+    return { TextResponseEvent: TextResponseEventFilterSensitiveLog(obj.TextResponseEvent) };
+  if (obj.AudioResponseEvent !== void 0)
+    return { AudioResponseEvent: obj.AudioResponseEvent };
+  if (obj.HeartbeatEvent !== void 0)
+    return { HeartbeatEvent: obj.HeartbeatEvent };
+  if (obj.AccessDeniedException !== void 0)
+    return { AccessDeniedException: obj.AccessDeniedException };
+  if (obj.ResourceNotFoundException !== void 0)
+    return { ResourceNotFoundException: obj.ResourceNotFoundException };
+  if (obj.ValidationException !== void 0)
+    return { ValidationException: obj.ValidationException };
+  if (obj.ThrottlingException !== void 0)
+    return { ThrottlingException: obj.ThrottlingException };
+  if (obj.InternalServerException !== void 0)
+    return { InternalServerException: obj.InternalServerException };
+  if (obj.ConflictException !== void 0)
+    return { ConflictException: obj.ConflictException };
+  if (obj.DependencyFailedException !== void 0)
+    return { DependencyFailedException: obj.DependencyFailedException };
+  if (obj.BadGatewayException !== void 0)
+    return { BadGatewayException: obj.BadGatewayException };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "StartConversationResponseEventStreamFilterSensitiveLog");
+var StartConversationResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.responseEventStream && { responseEventStream: "STREAMING_CONTENT" }
+}), "StartConversationResponseFilterSensitiveLog");
+
+// src/protocols/Aws_restJson1.ts
+var se_DeleteSessionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_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();
+}, "se_DeleteSessionCommand");
+var se_GetSessionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_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();
+}, "se_GetSessionCommand");
+var se_PutSessionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, 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(
+    (0, import_smithy_client.take)(input, {
+      messages: (_) => (0, import_smithy_client._json)(_),
+      requestAttributes: (_) => (0, import_smithy_client._json)(_),
+      sessionState: (_) => se_SessionState(_, context)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_PutSessionCommand");
+var se_RecognizeTextCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_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(
+    (0, import_smithy_client.take)(input, {
+      requestAttributes: (_) => (0, import_smithy_client._json)(_),
+      sessionState: (_) => se_SessionState(_, context),
+      text: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_RecognizeTextCommand");
+var se_RecognizeUtteranceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, 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 !== void 0) {
+    body = input.inputStream;
+  }
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_RecognizeUtteranceCommand");
+var se_StartConversationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    [_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 !== void 0) {
+    body = se_StartConversationRequestEventStream(input.requestEventStream, context);
+  }
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartConversationCommand");
+var de_DeleteSessionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteSessionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    botAliasId: import_smithy_client.expectString,
+    botId: import_smithy_client.expectString,
+    localeId: import_smithy_client.expectString,
+    sessionId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteSessionCommand");
+var de_DeleteSessionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.lexruntimev2#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.lexruntimev2#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.lexruntimev2#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.lexruntimev2#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.lexruntimev2#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.lexruntimev2#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteSessionCommandError");
+var de_GetSessionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetSessionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    interpretations: (_) => de_Interpretations(_, context),
+    messages: import_smithy_client._json,
+    sessionId: import_smithy_client.expectString,
+    sessionState: (_) => de_SessionState(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetSessionCommand");
+var de_GetSessionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.lexruntimev2#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.lexruntimev2#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.lexruntimev2#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.lexruntimev2#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.lexruntimev2#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetSessionCommandError");
+var de_PutSessionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_PutSessionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.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;
+}, "de_PutSessionCommand");
+var de_PutSessionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.lexruntimev2#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadGatewayException":
+    case "com.amazonaws.lexruntimev2#BadGatewayException":
+      throw await de_BadGatewayExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.lexruntimev2#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "DependencyFailedException":
+    case "com.amazonaws.lexruntimev2#DependencyFailedException":
+      throw await de_DependencyFailedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.lexruntimev2#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.lexruntimev2#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.lexruntimev2#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.lexruntimev2#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutSessionCommandError");
+var de_RecognizeTextCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_RecognizeTextCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    interpretations: (_) => de_Interpretations(_, context),
+    messages: import_smithy_client._json,
+    recognizedBotMember: import_smithy_client._json,
+    requestAttributes: import_smithy_client._json,
+    sessionId: import_smithy_client.expectString,
+    sessionState: (_) => de_SessionState(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_RecognizeTextCommand");
+var de_RecognizeTextCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.lexruntimev2#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadGatewayException":
+    case "com.amazonaws.lexruntimev2#BadGatewayException":
+      throw await de_BadGatewayExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.lexruntimev2#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "DependencyFailedException":
+    case "com.amazonaws.lexruntimev2#DependencyFailedException":
+      throw await de_DependencyFailedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.lexruntimev2#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.lexruntimev2#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.lexruntimev2#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.lexruntimev2#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RecognizeTextCommandError");
+var de_RecognizeUtteranceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_RecognizeUtteranceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.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;
+}, "de_RecognizeUtteranceCommand");
+var de_RecognizeUtteranceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.lexruntimev2#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadGatewayException":
+    case "com.amazonaws.lexruntimev2#BadGatewayException":
+      throw await de_BadGatewayExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.lexruntimev2#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "DependencyFailedException":
+    case "com.amazonaws.lexruntimev2#DependencyFailedException":
+      throw await de_DependencyFailedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.lexruntimev2#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.lexruntimev2#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.lexruntimev2#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.lexruntimev2#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RecognizeUtteranceCommandError");
+var de_StartConversationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartConversationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = output.body;
+  contents.responseEventStream = de_StartConversationResponseEventStream(data, context);
+  return contents;
+}, "de_StartConversationCommand");
+var de_StartConversationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.lexruntimev2#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.lexruntimev2#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.lexruntimev2#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.lexruntimev2#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartConversationCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(LexRuntimeV2ServiceException);
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessDeniedExceptionRes");
+var de_BadGatewayExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new BadGatewayException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_BadGatewayExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+var de_DependencyFailedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new DependencyFailedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_DependencyFailedExceptionRes");
+var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottlingExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ValidationExceptionRes");
+var se_StartConversationRequestEventStream = /* @__PURE__ */ __name((input, context) => {
+  const eventMarshallingVisitor = /* @__PURE__ */ __name((event) => 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
+  }), "eventMarshallingVisitor");
+  return context.eventStreamMarshaller.serialize(input, eventMarshallingVisitor);
+}, "se_StartConversationRequestEventStream");
+var se_AudioInputEvent_event = /* @__PURE__ */ __name((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 };
+}, "se_AudioInputEvent_event");
+var se_ConfigurationEvent_event = /* @__PURE__ */ __name((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, context);
+  body = context.utf8Decoder(JSON.stringify(body));
+  return { headers, body };
+}, "se_ConfigurationEvent_event");
+var se_DisconnectionEvent_event = /* @__PURE__ */ __name((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 = (0, import_smithy_client._json)(input);
+  body = context.utf8Decoder(JSON.stringify(body));
+  return { headers, body };
+}, "se_DisconnectionEvent_event");
+var se_DTMFInputEvent_event = /* @__PURE__ */ __name((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 = (0, import_smithy_client._json)(input);
+  body = context.utf8Decoder(JSON.stringify(body));
+  return { headers, body };
+}, "se_DTMFInputEvent_event");
+var se_PlaybackCompletionEvent_event = /* @__PURE__ */ __name((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 = (0, import_smithy_client._json)(input);
+  body = context.utf8Decoder(JSON.stringify(body));
+  return { headers, body };
+}, "se_PlaybackCompletionEvent_event");
+var se_TextInputEvent_event = /* @__PURE__ */ __name((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 = (0, import_smithy_client._json)(input);
+  body = context.utf8Decoder(JSON.stringify(body));
+  return { headers, body };
+}, "se_TextInputEvent_event");
+var de_StartConversationResponseEventStream = /* @__PURE__ */ __name((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: output };
+  });
+}, "de_StartConversationResponseEventStream");
+var de_AccessDeniedException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseBody(output.body, context)
+  };
+  return de_AccessDeniedExceptionRes(parsedOutput, context);
+}, "de_AccessDeniedException_event");
+var de_AudioResponseEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await parseBody(output.body, context);
+  Object.assign(contents, de_AudioResponseEvent(data, context));
+  return contents;
+}, "de_AudioResponseEvent_event");
+var de_BadGatewayException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseBody(output.body, context)
+  };
+  return de_BadGatewayExceptionRes(parsedOutput, context);
+}, "de_BadGatewayException_event");
+var de_ConflictException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseBody(output.body, context)
+  };
+  return de_ConflictExceptionRes(parsedOutput, context);
+}, "de_ConflictException_event");
+var de_DependencyFailedException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseBody(output.body, context)
+  };
+  return de_DependencyFailedExceptionRes(parsedOutput, context);
+}, "de_DependencyFailedException_event");
+var de_HeartbeatEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await parseBody(output.body, context);
+  Object.assign(contents, (0, import_smithy_client._json)(data));
+  return contents;
+}, "de_HeartbeatEvent_event");
+var de_IntentResultEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await parseBody(output.body, context);
+  Object.assign(contents, de_IntentResultEvent(data, context));
+  return contents;
+}, "de_IntentResultEvent_event");
+var de_InternalServerException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseBody(output.body, context)
+  };
+  return de_InternalServerExceptionRes(parsedOutput, context);
+}, "de_InternalServerException_event");
+var de_PlaybackInterruptionEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await parseBody(output.body, context);
+  Object.assign(contents, (0, import_smithy_client._json)(data));
+  return contents;
+}, "de_PlaybackInterruptionEvent_event");
+var de_ResourceNotFoundException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseBody(output.body, context)
+  };
+  return de_ResourceNotFoundExceptionRes(parsedOutput, context);
+}, "de_ResourceNotFoundException_event");
+var de_TextResponseEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await parseBody(output.body, context);
+  Object.assign(contents, (0, import_smithy_client._json)(data));
+  return contents;
+}, "de_TextResponseEvent_event");
+var de_ThrottlingException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseBody(output.body, context)
+  };
+  return de_ThrottlingExceptionRes(parsedOutput, context);
+}, "de_ThrottlingException_event");
+var de_TranscriptEvent_event = /* @__PURE__ */ __name(async (output, context) => {
+  const contents = {};
+  const data = await parseBody(output.body, context);
+  Object.assign(contents, (0, import_smithy_client._json)(data));
+  return contents;
+}, "de_TranscriptEvent_event");
+var de_ValidationException_event = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseBody(output.body, context)
+  };
+  return de_ValidationExceptionRes(parsedOutput, context);
+}, "de_ValidationException_event");
+var se_AudioInputEvent = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    audioChunk: context.base64Encoder,
+    clientTimestampMillis: [],
+    contentType: [],
+    eventId: []
+  });
+}, "se_AudioInputEvent");
+var se_ConfigurationEvent = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    clientTimestampMillis: [],
+    disablePlayback: [],
+    eventId: [],
+    requestAttributes: import_smithy_client._json,
+    responseContentType: [],
+    sessionState: (_) => se_SessionState(_, context),
+    welcomeMessages: import_smithy_client._json
+  });
+}, "se_ConfigurationEvent");
+var se_DialogAction = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    slotElicitationStyle: [],
+    slotToElicit: [],
+    subSlotToElicit: (_) => se_ElicitSubSlot(_, context),
+    type: []
+  });
+}, "se_DialogAction");
+var se_ElicitSubSlot = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    name: [],
+    subSlotToElicit: (_) => se_ElicitSubSlot(_, context)
+  });
+}, "se_ElicitSubSlot");
+var se_Intent = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    confirmationState: [],
+    name: [],
+    slots: (_) => se_Slots(_, context),
+    state: []
+  });
+}, "se_Intent");
+var se_RuntimeHintDetails = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    runtimeHintValues: import_smithy_client._json,
+    subSlotHints: (_) => se_SlotHintsSlotMap(_, context)
+  });
+}, "se_RuntimeHintDetails");
+var se_RuntimeHints = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    slotHints: (_) => se_SlotHintsIntentMap(_, context)
+  });
+}, "se_RuntimeHints");
+var se_SessionState = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    activeContexts: import_smithy_client._json,
+    dialogAction: (_) => se_DialogAction(_, context),
+    intent: (_) => se_Intent(_, context),
+    originatingRequestId: [],
+    runtimeHints: (_) => se_RuntimeHints(_, context),
+    sessionAttributes: import_smithy_client._json
+  });
+}, "se_SessionState");
+var se_Slot = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    shape: [],
+    subSlots: (_) => se_Slots(_, context),
+    value: import_smithy_client._json,
+    values: (_) => se_Values(_, context)
+  });
+}, "se_Slot");
+var se_SlotHintsIntentMap = /* @__PURE__ */ __name((input, context) => {
+  return Object.entries(input).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = se_SlotHintsSlotMap(value, context);
+    return acc;
+  }, {});
+}, "se_SlotHintsIntentMap");
+var se_SlotHintsSlotMap = /* @__PURE__ */ __name((input, context) => {
+  return Object.entries(input).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = se_RuntimeHintDetails(value, context);
+    return acc;
+  }, {});
+}, "se_SlotHintsSlotMap");
+var se_Slots = /* @__PURE__ */ __name((input, context) => {
+  return Object.entries(input).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = se_Slot(value, context);
+    return acc;
+  }, {});
+}, "se_Slots");
+var se_Values = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Slot(entry, context);
+  });
+}, "se_Values");
+var de_AudioResponseEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    audioChunk: context.base64Decoder,
+    contentType: import_smithy_client.expectString,
+    eventId: import_smithy_client.expectString
+  });
+}, "de_AudioResponseEvent");
+var de_ConfidenceScore = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    score: import_smithy_client.limitedParseDouble
+  });
+}, "de_ConfidenceScore");
+var de_DialogAction = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    slotElicitationStyle: import_smithy_client.expectString,
+    slotToElicit: import_smithy_client.expectString,
+    subSlotToElicit: (_) => de_ElicitSubSlot(_, context),
+    type: import_smithy_client.expectString
+  });
+}, "de_DialogAction");
+var de_ElicitSubSlot = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    name: import_smithy_client.expectString,
+    subSlotToElicit: (_) => de_ElicitSubSlot(_, context)
+  });
+}, "de_ElicitSubSlot");
+var de_Intent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    confirmationState: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    slots: (_) => de_Slots(_, context),
+    state: import_smithy_client.expectString
+  });
+}, "de_Intent");
+var de_IntentResultEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    eventId: import_smithy_client.expectString,
+    inputMode: import_smithy_client.expectString,
+    interpretations: (_) => de_Interpretations(_, context),
+    recognizedBotMember: import_smithy_client._json,
+    requestAttributes: import_smithy_client._json,
+    sessionId: import_smithy_client.expectString,
+    sessionState: (_) => de_SessionState(_, context)
+  });
+}, "de_IntentResultEvent");
+var de_Interpretation = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    intent: (_) => de_Intent(_, context),
+    interpretationSource: import_smithy_client.expectString,
+    nluConfidence: (_) => de_ConfidenceScore(_, context),
+    sentimentResponse: (_) => de_SentimentResponse(_, context)
+  });
+}, "de_Interpretation");
+var de_Interpretations = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Interpretation(entry, context);
+  });
+  return retVal;
+}, "de_Interpretations");
+var de_RuntimeHintDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    runtimeHintValues: import_smithy_client._json,
+    subSlotHints: (_) => de_SlotHintsSlotMap(_, context)
+  });
+}, "de_RuntimeHintDetails");
+var de_RuntimeHints = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    slotHints: (_) => de_SlotHintsIntentMap(_, context)
+  });
+}, "de_RuntimeHints");
+var de_SentimentResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    sentiment: import_smithy_client.expectString,
+    sentimentScore: (_) => de_SentimentScore(_, context)
+  });
+}, "de_SentimentResponse");
+var de_SentimentScore = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    mixed: import_smithy_client.limitedParseDouble,
+    negative: import_smithy_client.limitedParseDouble,
+    neutral: import_smithy_client.limitedParseDouble,
+    positive: import_smithy_client.limitedParseDouble
+  });
+}, "de_SentimentScore");
+var de_SessionState = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    activeContexts: import_smithy_client._json,
+    dialogAction: (_) => de_DialogAction(_, context),
+    intent: (_) => de_Intent(_, context),
+    originatingRequestId: import_smithy_client.expectString,
+    runtimeHints: (_) => de_RuntimeHints(_, context),
+    sessionAttributes: import_smithy_client._json
+  });
+}, "de_SessionState");
+var de_Slot = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    shape: import_smithy_client.expectString,
+    subSlots: (_) => de_Slots(_, context),
+    value: import_smithy_client._json,
+    values: (_) => de_Values(_, context)
+  });
+}, "de_Slot");
+var de_SlotHintsIntentMap = /* @__PURE__ */ __name((output, context) => {
+  return Object.entries(output).reduce(
+    (acc, [key, value]) => {
+      if (value === null) {
+        return acc;
+      }
+      acc[key] = de_SlotHintsSlotMap(value, context);
+      return acc;
+    },
+    {}
+  );
+}, "de_SlotHintsIntentMap");
+var de_SlotHintsSlotMap = /* @__PURE__ */ __name((output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_RuntimeHintDetails(value, context);
+    return acc;
+  }, {});
+}, "de_SlotHintsSlotMap");
+var de_Slots = /* @__PURE__ */ __name((output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_Slot(value, context);
+    return acc;
+  }, {});
+}, "de_Slots");
+var de_Values = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Slot(entry, context);
+  });
+  return retVal;
+}, "de_Values");
+var deserializeMetadata = /* @__PURE__ */ __name((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"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var isSerializableHeaderValue = /* @__PURE__ */ __name((value) => value !== void 0 && value !== null && value !== "" && (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) && (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0), "isSerializableHeaderValue");
+var _cM = "conversationMode";
+var _cT = "contentType";
+var _ct = "content-type";
+var _i = "interpretations";
+var _iM = "inputMode";
+var _iT = "inputTranscript";
+var _m = "messages";
+var _r = "responsecontenttype";
+var _rA = "requestAttributes";
+var _rBM = "recognizedBotMember";
+var _rCT = "responseContentType";
+var _rCTe = "requestContentType";
+var _rct = "response-content-type";
+var _sI = "sessionId";
+var _sS = "sessionState";
+var _xalcm = "x-amz-lex-conversation-mode";
+var _xali = "x-amz-lex-interpretations";
+var _xalim = "x-amz-lex-input-mode";
+var _xalit = "x-amz-lex-input-transcript";
+var _xalm = "x-amz-lex-messages";
+var _xalra = "x-amz-lex-request-attributes";
+var _xalrbm = "x-amz-lex-recognized-bot-member";
+var _xalsi = "x-amz-lex-session-id";
+var _xalss = "x-amz-lex-session-state";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/DeleteSessionCommand.ts
+var _DeleteSessionCommand = class _DeleteSessionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSDeepSenseRunTimeServiceApi2_0", "DeleteSession", {}).n("LexRuntimeV2Client", "DeleteSessionCommand").f(void 0, void 0).ser(se_DeleteSessionCommand).de(de_DeleteSessionCommand).build() {
+};
+__name(_DeleteSessionCommand, "DeleteSessionCommand");
+var DeleteSessionCommand = _DeleteSessionCommand;
+
+// src/commands/GetSessionCommand.ts
+
+
+
+
+var _GetSessionCommand = class _GetSessionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSDeepSenseRunTimeServiceApi2_0", "GetSession", {}).n("LexRuntimeV2Client", "GetSessionCommand").f(void 0, GetSessionResponseFilterSensitiveLog).ser(se_GetSessionCommand).de(de_GetSessionCommand).build() {
+};
+__name(_GetSessionCommand, "GetSessionCommand");
+var GetSessionCommand = _GetSessionCommand;
+
+// src/commands/PutSessionCommand.ts
+
+
+
+
+var _PutSessionCommand = class _PutSessionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSDeepSenseRunTimeServiceApi2_0", "PutSession", {}).n("LexRuntimeV2Client", "PutSessionCommand").f(PutSessionRequestFilterSensitiveLog, PutSessionResponseFilterSensitiveLog).ser(se_PutSessionCommand).de(de_PutSessionCommand).build() {
+};
+__name(_PutSessionCommand, "PutSessionCommand");
+var PutSessionCommand = _PutSessionCommand;
+
+// src/commands/RecognizeTextCommand.ts
+
+
+
+
+var _RecognizeTextCommand = class _RecognizeTextCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSDeepSenseRunTimeServiceApi2_0", "RecognizeText", {}).n("LexRuntimeV2Client", "RecognizeTextCommand").f(RecognizeTextRequestFilterSensitiveLog, RecognizeTextResponseFilterSensitiveLog).ser(se_RecognizeTextCommand).de(de_RecognizeTextCommand).build() {
+};
+__name(_RecognizeTextCommand, "RecognizeTextCommand");
+var RecognizeTextCommand = _RecognizeTextCommand;
+
+// src/commands/RecognizeUtteranceCommand.ts
+
+
+
+
+var _RecognizeUtteranceCommand = class _RecognizeUtteranceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSDeepSenseRunTimeServiceApi2_0", "RecognizeUtterance", {}).n("LexRuntimeV2Client", "RecognizeUtteranceCommand").f(RecognizeUtteranceRequestFilterSensitiveLog, RecognizeUtteranceResponseFilterSensitiveLog).ser(se_RecognizeUtteranceCommand).de(de_RecognizeUtteranceCommand).build() {
+};
+__name(_RecognizeUtteranceCommand, "RecognizeUtteranceCommand");
+var RecognizeUtteranceCommand = _RecognizeUtteranceCommand;
+
+// src/commands/StartConversationCommand.ts
+
+
+
+
+
+var _StartConversationCommand = class _StartConversationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()),
+    (0, import_middleware_eventstream.getEventStreamPlugin)(config)
+  ];
+}).s("AWSDeepSenseRunTimeServiceApi2_0", "StartConversation", {
+  /**
+   * @internal
+   */
+  eventStream: {
+    input: true,
+    output: true
+  }
+}).n("LexRuntimeV2Client", "StartConversationCommand").f(StartConversationRequestFilterSensitiveLog, StartConversationResponseFilterSensitiveLog).ser(se_StartConversationCommand).de(de_StartConversationCommand).build() {
+};
+__name(_StartConversationCommand, "StartConversationCommand");
+var StartConversationCommand = _StartConversationCommand;
+
+// src/LexRuntimeV2.ts
+var commands = {
+  DeleteSessionCommand,
+  GetSessionCommand,
+  PutSessionCommand,
+  RecognizeTextCommand,
+  RecognizeUtteranceCommand,
+  StartConversationCommand
+};
+var _LexRuntimeV2 = class _LexRuntimeV2 extends LexRuntimeV2Client {
+};
+__name(_LexRuntimeV2, "LexRuntimeV2");
+var LexRuntimeV2 = _LexRuntimeV2;
+(0, import_smithy_client.createAggregatedClient)(commands, LexRuntimeV2);
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccessDeniedException,
+  ActiveContextFilterSensitiveLog,
+  BadGatewayException,
+  ConfigurationEventFilterSensitiveLog,
+  ConfirmationState,
+  ConflictException,
+  ConversationMode,
+  DTMFInputEventFilterSensitiveLog,
+  DeleteSessionCommand,
+  DependencyFailedException,
+  DialogActionType,
+  GetSessionCommand,
+  GetSessionResponseFilterSensitiveLog,
+  InputMode,
+  IntentResultEventFilterSensitiveLog,
+  IntentState,
+  InternalServerException,
+  InterpretationSource,
+  LexRuntimeV2,
+  LexRuntimeV2Client,
+  LexRuntimeV2ServiceException,
+  MessageContentType,
+  MessageFilterSensitiveLog,
+  PlaybackInterruptionReason,
+  PutSessionCommand,
+  PutSessionRequestFilterSensitiveLog,
+  PutSessionResponseFilterSensitiveLog,
+  RecognizeTextCommand,
+  RecognizeTextRequestFilterSensitiveLog,
+  RecognizeTextResponseFilterSensitiveLog,
+  RecognizeUtteranceCommand,
+  RecognizeUtteranceRequestFilterSensitiveLog,
+  RecognizeUtteranceResponseFilterSensitiveLog,
+  ResourceNotFoundException,
+  SentimentType,
+  SessionStateFilterSensitiveLog,
+  Shape,
+  StartConversationCommand,
+  StartConversationRequestEventStream,
+  StartConversationRequestEventStreamFilterSensitiveLog,
+  StartConversationRequestFilterSensitiveLog,
+  StartConversationResponseEventStream,
+  StartConversationResponseEventStreamFilterSensitiveLog,
+  StartConversationResponseFilterSensitiveLog,
+  StyleType,
+  TextInputEventFilterSensitiveLog,
+  TextResponseEventFilterSensitiveLog,
+  ThrottlingException,
+  ValidationException,
+  __Client
+});