@aws-sdk/client-lex-runtime-service 3.186.0 → 3.186.1

package/dist-types/ts3.4/commands/DeleteSessionCommand.d.ts

@@ -1,35 +1,36 @@
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  LexRuntimeServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexRuntimeServiceClient";
-import {
-  DeleteSessionRequest,
-  DeleteSessionResponse,
-} from "../models/models_0";
-export interface DeleteSessionCommandInput extends DeleteSessionRequest {}
-export interface DeleteSessionCommandOutput
-  extends DeleteSessionResponse,
-    __MetadataBearer {}
-export declare class DeleteSessionCommand extends $Command<
-  DeleteSessionCommandInput,
-  DeleteSessionCommandOutput,
-  LexRuntimeServiceClientResolvedConfig
-> {
-  readonly input: DeleteSessionCommandInput;
-  constructor(input: DeleteSessionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexRuntimeServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteSessionCommandInput, DeleteSessionCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexRuntimeServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexRuntimeServiceClient";
+import { DeleteSessionRequest, DeleteSessionResponse } from "../models/models_0";
+export interface DeleteSessionCommandInput extends DeleteSessionRequest {
+}
+export interface DeleteSessionCommandOutput extends DeleteSessionResponse, __MetadataBearer {
+}
+/**
+ * <p>Removes session information for a specified bot, alias, and user ID.
+ *     </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexRuntimeServiceClient, DeleteSessionCommand } from "@aws-sdk/client-lex-runtime-service"; // ES Modules import
+ * // const { LexRuntimeServiceClient, DeleteSessionCommand } = require("@aws-sdk/client-lex-runtime-service"); // CommonJS import
+ * const client = new LexRuntimeServiceClient(config);
+ * const command = new DeleteSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteSessionCommandInput} for command's `input` shape.
+ * @see {@link DeleteSessionCommandOutput} for command's `response` shape.
+ * @see {@link LexRuntimeServiceClientResolvedConfig | config} for LexRuntimeServiceClient's `config` shape.
+ *
+ */
+export declare class DeleteSessionCommand extends $Command<DeleteSessionCommandInput, DeleteSessionCommandOutput, LexRuntimeServiceClientResolvedConfig> {
+    readonly input: DeleteSessionCommandInput;
+    constructor(input: DeleteSessionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexRuntimeServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSessionCommandInput, DeleteSessionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetSessionCommand.d.ts

@@ -1,32 +1,36 @@
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  LexRuntimeServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexRuntimeServiceClient";
-import { GetSessionRequest, GetSessionResponse } from "../models/models_0";
-export interface GetSessionCommandInput extends GetSessionRequest {}
-export interface GetSessionCommandOutput
-  extends GetSessionResponse,
-    __MetadataBearer {}
-export declare class GetSessionCommand extends $Command<
-  GetSessionCommandInput,
-  GetSessionCommandOutput,
-  LexRuntimeServiceClientResolvedConfig
-> {
-  readonly input: GetSessionCommandInput;
-  constructor(input: GetSessionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexRuntimeServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<GetSessionCommandInput, GetSessionCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexRuntimeServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexRuntimeServiceClient";
+import { GetSessionRequest, GetSessionResponse } from "../models/models_0";
+export interface GetSessionCommandInput extends GetSessionRequest {
+}
+export interface GetSessionCommandOutput extends GetSessionResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns session information for a specified bot, alias, and user
+ *       ID.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexRuntimeServiceClient, GetSessionCommand } from "@aws-sdk/client-lex-runtime-service"; // ES Modules import
+ * // const { LexRuntimeServiceClient, GetSessionCommand } = require("@aws-sdk/client-lex-runtime-service"); // CommonJS import
+ * const client = new LexRuntimeServiceClient(config);
+ * const command = new GetSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSessionCommandInput} for command's `input` shape.
+ * @see {@link GetSessionCommandOutput} for command's `response` shape.
+ * @see {@link LexRuntimeServiceClientResolvedConfig | config} for LexRuntimeServiceClient's `config` shape.
+ *
+ */
+export declare class GetSessionCommand extends $Command<GetSessionCommandInput, GetSessionCommandOutput, LexRuntimeServiceClientResolvedConfig> {
+    readonly input: GetSessionCommandInput;
+    constructor(input: GetSessionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexRuntimeServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSessionCommandInput, GetSessionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/PostContentCommand.d.ts

@@ -1,39 +1,122 @@
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  LexRuntimeServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexRuntimeServiceClient";
-import { PostContentRequest, PostContentResponse } from "../models/models_0";
-declare type PostContentCommandInputType = Pick<
-  PostContentRequest,
-  Exclude<keyof PostContentRequest, "inputStream">
-> & {
-  inputStream: PostContentRequest["inputStream"] | string | Uint8Array | Buffer;
-};
-export interface PostContentCommandInput extends PostContentCommandInputType {}
-export interface PostContentCommandOutput
-  extends PostContentResponse,
-    __MetadataBearer {}
-export declare class PostContentCommand extends $Command<
-  PostContentCommandInput,
-  PostContentCommandOutput,
-  LexRuntimeServiceClientResolvedConfig
-> {
-  readonly input: PostContentCommandInput;
-  constructor(input: PostContentCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexRuntimeServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PostContentCommandInput, PostContentCommandOutput>;
-  private serialize;
-  private deserialize;
-}
-export {};
+/// <reference types="node" />
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexRuntimeServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexRuntimeServiceClient";
+import { PostContentRequest, PostContentResponse } from "../models/models_0";
+declare type PostContentCommandInputType = Pick<PostContentRequest, Exclude<keyof PostContentRequest, "inputStream">> & {
+    /**
+     * For *`PostContentRequest["inputStream"]`*, see {@link PostContentRequest.inputStream}.
+     */
+    inputStream: PostContentRequest["inputStream"] | string | Uint8Array | Buffer;
+};
+/**
+ * This interface extends from `PostContentRequest` interface. There are more parameters than `inputStream` defined in {@link PostContentRequest}
+ */
+export interface PostContentCommandInput extends PostContentCommandInputType {
+}
+export interface PostContentCommandOutput extends PostContentResponse, __MetadataBearer {
+}
+/**
+ * <p> Sends user input (text or speech) to Amazon Lex. Clients use this API to
+ *       send text and audio requests to Amazon Lex at runtime. Amazon Lex interprets the
+ *       user input using the machine learning model that it built for the bot. </p>
+ *          <p>The <code>PostContent</code> operation supports audio input at 8kHz
+ *       and 16kHz. You can use 8kHz audio to achieve higher speech recognition
+ *       accuracy in telephone audio applications. </p>
+ *          <p> In response, Amazon Lex returns the next message to convey to the user.
+ *       Consider the following example messages: </p>
+ *          <ul>
+ *             <li>
+ *                <p> For a user input "I would like a pizza," Amazon Lex might return a
+ *           response with a message eliciting slot data (for example,
+ *             <code>PizzaSize</code>): "What size pizza would you like?". </p>
+ *             </li>
+ *             <li>
+ *                <p> After the user provides all of the pizza order information, Amazon Lex
+ *           might return a response with a message to get user confirmation:
+ *           "Order the pizza?". </p>
+ *             </li>
+ *             <li>
+ *                <p> After the user replies "Yes" to the confirmation prompt, Amazon Lex
+ *           might return a conclusion statement: "Thank you, your cheese pizza has
+ *           been ordered.". </p>
+ *             </li>
+ *          </ul>
+ *          <p> Not all Amazon Lex messages require a response from the user. For example,
+ *       conclusion statements do not require a response. Some messages require
+ *       only a yes or no response. In addition to the <code>message</code>, Amazon Lex
+ *       provides additional context about the message in the response that you can
+ *       use to enhance client behavior, such as displaying the appropriate client
+ *       user interface. Consider the following examples: </p>
+ *          <ul>
+ *             <li>
+ *                <p> If the message is to elicit slot data, Amazon Lex returns the
+ *           following context information: </p>
+ *                <ul>
+ *                   <li>
+ *                      <p>
+ *                         <code>x-amz-lex-dialog-state</code> header set to
+ *                 <code>ElicitSlot</code>
+ *                      </p>
+ *                   </li>
+ *                   <li>
+ *                      <p>
+ *                         <code>x-amz-lex-intent-name</code> header set to the intent name
+ *               in the current context </p>
+ *                   </li>
+ *                   <li>
+ *                      <p>
+ *                         <code>x-amz-lex-slot-to-elicit</code> header set to the slot name
+ *               for which the <code>message</code> is eliciting information
+ *             </p>
+ *                   </li>
+ *                   <li>
+ *                      <p>
+ *                         <code>x-amz-lex-slots</code> header set to a map of slots
+ *               configured for the intent with their current values </p>
+ *                   </li>
+ *                </ul>
+ *             </li>
+ *             <li>
+ *                <p> If the message is a confirmation prompt, the
+ *             <code>x-amz-lex-dialog-state</code> header is set to
+ *             <code>Confirmation</code> and the
+ *             <code>x-amz-lex-slot-to-elicit</code> header is omitted. </p>
+ *             </li>
+ *             <li>
+ *                <p> If the message is a clarification prompt configured for the
+ *           intent, indicating that the user intent is not understood, the
+ *             <code>x-amz-dialog-state</code> header is set to
+ *             <code>ElicitIntent</code> and the <code>x-amz-slot-to-elicit</code>
+ *           header is omitted. </p>
+ *             </li>
+ *          </ul>
+ *          <p> In addition, Amazon Lex also returns your application-specific
+ *         <code>sessionAttributes</code>. For more information, see <a href="https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html">Managing
+ *         Conversation Context</a>. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexRuntimeServiceClient, PostContentCommand } from "@aws-sdk/client-lex-runtime-service"; // ES Modules import
+ * // const { LexRuntimeServiceClient, PostContentCommand } = require("@aws-sdk/client-lex-runtime-service"); // CommonJS import
+ * const client = new LexRuntimeServiceClient(config);
+ * const command = new PostContentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PostContentCommandInput} for command's `input` shape.
+ * @see {@link PostContentCommandOutput} for command's `response` shape.
+ * @see {@link LexRuntimeServiceClientResolvedConfig | config} for LexRuntimeServiceClient's `config` shape.
+ *
+ */
+export declare class PostContentCommand extends $Command<PostContentCommandInput, PostContentCommandOutput, LexRuntimeServiceClientResolvedConfig> {
+    readonly input: PostContentCommandInput;
+    constructor(input: PostContentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexRuntimeServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PostContentCommandInput, PostContentCommandOutput>;
+    private serialize;
+    private deserialize;
+}
+export {};

package/dist-types/ts3.4/commands/PostTextCommand.d.ts

@@ -1,32 +1,110 @@
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  LexRuntimeServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexRuntimeServiceClient";
-import { PostTextRequest, PostTextResponse } from "../models/models_0";
-export interface PostTextCommandInput extends PostTextRequest {}
-export interface PostTextCommandOutput
-  extends PostTextResponse,
-    __MetadataBearer {}
-export declare class PostTextCommand extends $Command<
-  PostTextCommandInput,
-  PostTextCommandOutput,
-  LexRuntimeServiceClientResolvedConfig
-> {
-  readonly input: PostTextCommandInput;
-  constructor(input: PostTextCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexRuntimeServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PostTextCommandInput, PostTextCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexRuntimeServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexRuntimeServiceClient";
+import { PostTextRequest, PostTextResponse } from "../models/models_0";
+export interface PostTextCommandInput extends PostTextRequest {
+}
+export interface PostTextCommandOutput extends PostTextResponse, __MetadataBearer {
+}
+/**
+ * <p>Sends user input to Amazon Lex. Client applications can use this API to
+ *       send requests to Amazon Lex at runtime. Amazon Lex then interprets the user input
+ *       using the machine learning model it built for the bot. </p>
+ *          <p> In response, Amazon Lex returns the next <code>message</code> to convey to
+ *       the user an optional <code>responseCard</code> to display. Consider the
+ *       following example messages: </p>
+ *          <ul>
+ *             <li>
+ *                <p> For a user input "I would like a pizza", Amazon Lex might return a
+ *           response with a message eliciting slot data (for example, PizzaSize):
+ *           "What size pizza would you like?" </p>
+ *             </li>
+ *             <li>
+ *                <p> After the user provides all of the pizza order information,
+ *           Amazon Lex might return a response with a message to obtain user
+ *           confirmation "Proceed with the pizza order?". </p>
+ *             </li>
+ *             <li>
+ *                <p> After the user replies to a confirmation prompt with a "yes",
+ *           Amazon Lex might return a conclusion statement: "Thank you, your cheese
+ *           pizza has been ordered.". </p>
+ *             </li>
+ *          </ul>
+ *
+ *          <p> Not all Amazon Lex messages require a user response. For example, a
+ *       conclusion statement does not require a response. Some messages require
+ *       only a "yes" or "no" user response. In addition to the
+ *         <code>message</code>, Amazon Lex provides additional context about the
+ *       message in the response that you might use to enhance client behavior, for
+ *       example, to display the appropriate client user interface. These are the
+ *         <code>slotToElicit</code>, <code>dialogState</code>,
+ *         <code>intentName</code>, and <code>slots</code> fields in the response.
+ *       Consider the following examples: </p>
+ *
+ *          <ul>
+ *             <li>
+ *                <p>If the message is to elicit slot data, Amazon Lex returns the
+ *           following context information:</p>
+ *                <ul>
+ *                   <li>
+ *                      <p>
+ *                         <code>dialogState</code> set to ElicitSlot </p>
+ *                   </li>
+ *                   <li>
+ *                      <p>
+ *                         <code>intentName</code> set to the intent name in the current
+ *               context </p>
+ *                   </li>
+ *                   <li>
+ *                      <p>
+ *                         <code>slotToElicit</code> set to the slot name for which the
+ *                 <code>message</code> is eliciting information </p>
+ *                   </li>
+ *                   <li>
+ *                      <p>
+ *                         <code>slots</code> set to a map of slots, configured for the
+ *               intent, with currently known values </p>
+ *                   </li>
+ *                </ul>
+ *             </li>
+ *             <li>
+ *                <p> If the message is a confirmation prompt, the
+ *             <code>dialogState</code> is set to ConfirmIntent and
+ *             <code>SlotToElicit</code> is set to null. </p>
+ *             </li>
+ *             <li>
+ *                <p>If the message is a clarification prompt (configured for the
+ *           intent) that indicates that user intent is not understood, the
+ *             <code>dialogState</code> is set to ElicitIntent and
+ *             <code>slotToElicit</code> is set to null. </p>
+ *             </li>
+ *          </ul>
+ *
+ *          <p> In addition, Amazon Lex also returns your application-specific
+ *         <code>sessionAttributes</code>. For more information, see <a href="https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html">Managing
+ *         Conversation Context</a>. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexRuntimeServiceClient, PostTextCommand } from "@aws-sdk/client-lex-runtime-service"; // ES Modules import
+ * // const { LexRuntimeServiceClient, PostTextCommand } = require("@aws-sdk/client-lex-runtime-service"); // CommonJS import
+ * const client = new LexRuntimeServiceClient(config);
+ * const command = new PostTextCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PostTextCommandInput} for command's `input` shape.
+ * @see {@link PostTextCommandOutput} for command's `response` shape.
+ * @see {@link LexRuntimeServiceClientResolvedConfig | config} for LexRuntimeServiceClient's `config` shape.
+ *
+ */
+export declare class PostTextCommand extends $Command<PostTextCommandInput, PostTextCommandOutput, LexRuntimeServiceClientResolvedConfig> {
+    readonly input: PostTextCommandInput;
+    constructor(input: PostTextCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexRuntimeServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PostTextCommandInput, PostTextCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/PutSessionCommand.d.ts

@@ -1,32 +1,39 @@
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  Handler,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-} from "@aws-sdk/types";
-import {
-  LexRuntimeServiceClientResolvedConfig,
-  ServiceInputTypes,
-  ServiceOutputTypes,
-} from "../LexRuntimeServiceClient";
-import { PutSessionRequest, PutSessionResponse } from "../models/models_0";
-export interface PutSessionCommandInput extends PutSessionRequest {}
-export interface PutSessionCommandOutput
-  extends PutSessionResponse,
-    __MetadataBearer {}
-export declare class PutSessionCommand extends $Command<
-  PutSessionCommandInput,
-  PutSessionCommandOutput,
-  LexRuntimeServiceClientResolvedConfig
-> {
-  readonly input: PutSessionCommandInput;
-  constructor(input: PutSessionCommandInput);
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: LexRuntimeServiceClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PutSessionCommandInput, PutSessionCommandOutput>;
-  private serialize;
-  private deserialize;
-}
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LexRuntimeServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LexRuntimeServiceClient";
+import { PutSessionRequest, PutSessionResponse } from "../models/models_0";
+export interface PutSessionCommandInput extends PutSessionRequest {
+}
+export interface PutSessionCommandOutput extends PutSessionResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a new session or modifies an existing session with an Amazon Lex
+ *       bot. Use this operation to enable your application to set the state of the
+ *       bot.</p>
+ *          <p>For more information, see <a href="https://docs.aws.amazon.com/lex/latest/dg/how-session-api.html">Managing
+ *         Sessions</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LexRuntimeServiceClient, PutSessionCommand } from "@aws-sdk/client-lex-runtime-service"; // ES Modules import
+ * // const { LexRuntimeServiceClient, PutSessionCommand } = require("@aws-sdk/client-lex-runtime-service"); // CommonJS import
+ * const client = new LexRuntimeServiceClient(config);
+ * const command = new PutSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutSessionCommandInput} for command's `input` shape.
+ * @see {@link PutSessionCommandOutput} for command's `response` shape.
+ * @see {@link LexRuntimeServiceClientResolvedConfig | config} for LexRuntimeServiceClient's `config` shape.
+ *
+ */
+export declare class PutSessionCommand extends $Command<PutSessionCommandInput, PutSessionCommandOutput, LexRuntimeServiceClientResolvedConfig> {
+    readonly input: PutSessionCommandInput;
+    constructor(input: PutSessionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LexRuntimeServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutSessionCommandInput, PutSessionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./DeleteSessionCommand";
-export * from "./GetSessionCommand";
-export * from "./PostContentCommand";
-export * from "./PostTextCommand";
-export * from "./PutSessionCommand";
+export * from "./DeleteSessionCommand";
+export * from "./GetSessionCommand";
+export * from "./PostContentCommand";
+export * from "./PostTextCommand";
+export * from "./PutSessionCommand";

package/dist-types/ts3.4/endpoints.d.ts

@@ -1,2 +1,2 @@
-import { RegionInfoProvider } from "@aws-sdk/types";
-export declare const defaultRegionInfoProvider: RegionInfoProvider;
+import { RegionInfoProvider } from "@aws-sdk/types";
+export declare const defaultRegionInfoProvider: RegionInfoProvider;

package/dist-types/ts3.4/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./LexRuntimeService";
-export * from "./LexRuntimeServiceClient";
-export * from "./commands";
-export * from "./models";
-export { LexRuntimeServiceServiceException } from "./models/LexRuntimeServiceServiceException";
+export * from "./LexRuntimeService";
+export * from "./LexRuntimeServiceClient";
+export * from "./commands";
+export * from "./models";
+export { LexRuntimeServiceServiceException } from "./models/LexRuntimeServiceServiceException";

package/dist-types/ts3.4/models/LexRuntimeServiceServiceException.d.ts

@@ -1,7 +1,10 @@
-import {
-  ServiceException as __ServiceException,
-  ServiceExceptionOptions as __ServiceExceptionOptions,
-} from "@aws-sdk/smithy-client";
-export declare class LexRuntimeServiceServiceException extends __ServiceException {
-  constructor(options: __ServiceExceptionOptions);
-}
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@aws-sdk/smithy-client";
+/**
+ * Base exception class for all service exceptions from LexRuntimeService service.
+ */
+export declare class LexRuntimeServiceServiceException extends __ServiceException {
+    /**
+     * @internal
+     */
+    constructor(options: __ServiceExceptionOptions);
+}

package/dist-types/ts3.4/models/index.d.ts

@@ -1 +1 @@
-export * from "./models_0";
+export * from "./models_0";