@aws-sdk/client-lex-runtime-service 3.36.0 → 3.39.0

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

@@ -14,135 +14,59 @@ import { PutSessionCommandInput, PutSessionCommandOutput } from "./commands/PutS
 export declare type ServiceInputTypes = DeleteSessionCommandInput | GetSessionCommandInput | PostContentCommandInput | PostTextCommandInput | PutSessionCommandInput;
 export declare type ServiceOutputTypes = DeleteSessionCommandOutput | GetSessionCommandOutput | PostContentCommandOutput | PostTextCommandOutput | PutSessionCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
-    /**
-     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
-     */
+    
     requestHandler?: __HttpHandler;
-    /**
-     * A constructor for a class implementing the {@link __Hash} interface
-     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
-     * @internal
-     */
+    
     sha256?: __HashConstructor;
-    /**
-     * The function that will be used to convert strings into HTTP endpoints.
-     * @internal
-     */
+    
     urlParser?: __UrlParser;
-    /**
-     * A function that can calculate the length of a request body.
-     * @internal
-     */
+    
     bodyLengthChecker?: (body: any) => number | undefined;
-    /**
-     * A function that converts a stream into an array of bytes.
-     * @internal
-     */
+    
     streamCollector?: __StreamCollector;
-    /**
-     * The function that will be used to convert a base64-encoded string to a byte array.
-     * @internal
-     */
+    
     base64Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a base64-encoded string.
-     * @internal
-     */
+    
     base64Encoder?: __Encoder;
-    /**
-     * The function that will be used to convert a UTF8-encoded string to a byte array.
-     * @internal
-     */
+    
     utf8Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a UTF-8 encoded string.
-     * @internal
-     */
+    
     utf8Encoder?: __Encoder;
-    /**
-     * The runtime environment.
-     * @internal
-     */
+    
     runtime?: string;
-    /**
-     * Disable dyanamically changing the endpoint of the client based on the hostPrefix
-     * trait of an operation.
-     */
+    
     disableHostPrefix?: boolean;
-    /**
-     * Value for how many times a request will be made at most in case of retry.
-     */
+    
     maxAttempts?: number | __Provider<number>;
-    /**
-     * Specifies which retry algorithm to use.
-     */
+    
     retryMode?: string | __Provider<string>;
-    /**
-     * Optional logger for logging debug/info/warn/error.
-     */
+    
     logger?: __Logger;
-    /**
-     * Unique service identifier.
-     * @internal
-     */
+    
     serviceId?: string;
-    /**
-     * The AWS region to which this client will send requests
-     */
+    
     region?: string | __Provider<string>;
-    /**
-     * Default credentials provider; Not available in browser runtime.
-     * @internal
-     */
+    
     credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
-    /**
-     * Fetch related hostname, signing name or signing region with given region.
-     * @internal
-     */
+    
     regionInfoProvider?: RegionInfoProvider;
-    /**
-     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
-     * @internal
-     */
+    
     defaultUserAgentProvider?: Provider<__UserAgent>;
 }
 declare type LexRuntimeServiceClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
-/**
- * The configuration interface of LexRuntimeServiceClient class constructor that set the region, credentials and other options.
- */
+
 export interface LexRuntimeServiceClientConfig extends LexRuntimeServiceClientConfigType {
 }
 declare type LexRuntimeServiceClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
-/**
- * The resolved configuration interface of LexRuntimeServiceClient class. This is resolved and normalized from the {@link LexRuntimeServiceClientConfig | constructor configuration interface}.
- */
+
 export interface LexRuntimeServiceClientResolvedConfig extends LexRuntimeServiceClientResolvedConfigType {
 }
-/**
- * <p>Amazon Lex provides both build and runtime endpoints. Each endpoint
- *       provides a set of operations (API). Your conversational bot uses the
- *       runtime API to understand user utterances (user input text or voice). For
- *       example, suppose a user says "I want pizza", your bot sends this input to
- *       Amazon Lex using the runtime API. Amazon Lex recognizes that the user
- *       request is for the OrderPizza intent (one of the intents defined in the
- *       bot). Then Amazon Lex engages in user conversation on behalf of the bot to
- *       elicit required information (slot values, such as pizza size and crust
- *       type), and then performs fulfillment activity (that you configured when
- *       you created the bot). You use the build-time API to create and manage your
- *       Amazon Lex bot. For a list of build-time operations, see the build-time
- *       API, . </p>
- */
+
 export declare class LexRuntimeServiceClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, LexRuntimeServiceClientResolvedConfig> {
-    /**
-     * The resolved configuration of LexRuntimeServiceClient class. This is resolved and normalized from the {@link LexRuntimeServiceClientConfig | constructor configuration interface}.
-     */
+    
     readonly config: LexRuntimeServiceClientResolvedConfig;
     constructor(configuration: LexRuntimeServiceClientConfig);
-    /**
-     * 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(): void;
 }
 export {};

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

@@ -6,30 +6,11 @@ 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 command's `input` 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

@@ -6,30 +6,11 @@ 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 command's `input` 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,120 +1,22 @@
-/// <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 command's `input` 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;

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

@@ -6,104 +6,11 @@ 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 command's `input` 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

@@ -6,33 +6,11 @@ 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 command's `input` 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

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

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

@@ -1,8 +1,4 @@
-export * from "./LexRuntimeServiceClient";
 export * from "./LexRuntimeService";
-export * from "./commands/DeleteSessionCommand";
-export * from "./commands/GetSessionCommand";
-export * from "./commands/PostContentCommand";
-export * from "./commands/PostTextCommand";
-export * from "./commands/PutSessionCommand";
-export * from "./models/index";
+export * from "./LexRuntimeServiceClient";
+export * from "./commands";
+export * from "./models";