@aws-sdk/client-lex-runtime-service

/// <reference types="node" /> import { LazyJsonString as __LazyJsonString, SmithyException as __SmithyException } from "@aws-sdk/smithy-client"; import { MetadataBearer as $MetadataBearer } from "@aws-sdk/types"; import { Readable } from "stream"; /** * The length of time or number of turns that a context remains active. */ export interface ActiveContextTimeToLive { /** * The number of seconds that the context should be active after it is first sent in a * <code>PostContent</code> or <code>PostText</code> response. You can set the value between 5 * and 86,400 seconds (24 hours). */ timeToLiveInSeconds?: number; /** * The number of conversation turns that the context should be active. A conversation turn is * one <code>PostContent</code> or <code>PostText</code> request and the corresponding response * from Amazon Lex. */ turnsToLive?: number; } export declare namespace ActiveContextTimeToLive { const filterSensitiveLog: (obj: ActiveContextTimeToLive) => any; } /** * A context is a variable that contains information about the current state of the * conversation between a user and Amazon Lex. Context can be set automatically by Amazon Lex when an * intent is fulfilled, or it can be set at runtime using the <code>PutContent</code>, * <code>PutText</code>, or <code>PutSession</code> operation. */ export interface ActiveContext { /** * The name of the context. */ name: string | undefined; /** * The length of time or number of turns that a context remains active. */ timeToLive: ActiveContextTimeToLive | undefined; /** * State variables for the current context. You can use these values as default values for * slots in subsequent events. */ parameters: { [key: string]: string; } | undefined; } export declare namespace ActiveContext { const filterSensitiveLog: (obj: ActiveContext) => any; } /** * Request validation failed, there is no usable message in the context, or the bot build * failed, is still in progress, or contains unbuilt changes. */ export interface BadRequestException extends __SmithyException, $MetadataBearer { name: "BadRequestException"; $fault: "client"; message?: string; } export declare namespace BadRequestException { const filterSensitiveLog: (obj: BadRequestException) => any; } /** * Two clients are using the same AWS account, Amazon Lex bot, and user ID. */ export interface ConflictException extends __SmithyException, $MetadataBearer { name: "ConflictException"; $fault: "client"; message?: string; } export declare namespace ConflictException { const filterSensitiveLog: (obj: ConflictException) => any; } export interface DeleteSessionRequest { /** * The name of the bot that contains the session data. */ botName: string | undefined; /** * The alias in use for the bot that contains the session data. */ botAlias: string | undefined; /** * The identifier of the user associated with the session data. */ userId: string | undefined; } export declare namespace DeleteSessionRequest { const filterSensitiveLog: (obj: DeleteSessionRequest) => any; } export interface DeleteSessionResponse { /** * The name of the bot associated with the session data. */ botName?: string; /** * The alias in use for the bot associated with the session data. */ botAlias?: string; /** * The ID of the client application user. */ userId?: string; /** * The unique identifier for the session. */ sessionId?: string; } export declare namespace DeleteSessionResponse { const filterSensitiveLog: (obj: DeleteSessionResponse) => any; } /** * Internal service error. Retry the call. */ export interface InternalFailureException extends __SmithyException, $MetadataBearer { name: "InternalFailureException"; $fault: "server"; message?: string; } export declare namespace InternalFailureException { const filterSensitiveLog: (obj: InternalFailureException) => any; } /** * Exceeded a limit. */ export interface LimitExceededException extends __SmithyException, $MetadataBearer { name: "LimitExceededException"; $fault: "client"; retryAfterSeconds?: string; message?: string; } export declare namespace LimitExceededException { const filterSensitiveLog: (obj: LimitExceededException) => any; } /** * The resource (such as the Amazon Lex bot or an alias) that is referred to is not * found. */ export interface NotFoundException extends __SmithyException, $MetadataBearer { name: "NotFoundException"; $fault: "client"; message?: string; } export declare namespace NotFoundException { const filterSensitiveLog: (obj: NotFoundException) => any; } export interface GetSessionRequest { /** * The name of the bot that contains the session data. */ botName: string | undefined; /** * The alias in use for the bot that contains the session data. */ botAlias: string | undefined; /** * The ID of the client application user. Amazon Lex uses this to identify a user's conversation * with your bot. */ userId: string | undefined; /** * A string used to filter the intents returned in the <code>recentIntentSummaryView</code> * structure. * When you specify a filter, only intents with their <code>checkpointLabel</code> field set * to that string are returned. */ checkpointLabelFilter?: string; } export declare namespace GetSessionRequest { const filterSensitiveLog: (obj: GetSessionRequest) => any; } export declare enum FulfillmentState { FAILED = "Failed", FULFILLED = "Fulfilled", READY_FOR_FULFILLMENT = "ReadyForFulfillment" } export declare enum MessageFormatType { COMPOSITE = "Composite", CUSTOM_PAYLOAD = "CustomPayload", PLAIN_TEXT = "PlainText", SSML = "SSML" } export declare enum DialogActionType { CLOSE = "Close", CONFIRM_INTENT = "ConfirmIntent", DELEGATE = "Delegate", ELICIT_INTENT = "ElicitIntent", ELICIT_SLOT = "ElicitSlot" } /** * Describes the next action that the bot should take in its interaction with the user and * provides information about the context in which the action takes place. Use the * <code>DialogAction</code> data type to set the interaction to a specific state, or to return * the interaction to a previous state. */ export interface DialogAction { /** * The next action that the bot should take in its interaction with the user. The possible * values are: * <ul> * <li> * * <code>ConfirmIntent</code> - The next action is asking the user if the intent is * complete and ready to be fulfilled. This is a yes/no question such as "Place the * order?" * </li> * <li> * * <code>Close</code> - Indicates that the there will not be a response from the user. * For example, the statement "Your order has been placed" does not require a * response. * </li> * <li> * * <code>Delegate</code> - The next action is determined by Amazon Lex. * </li> * <li> * * <code>ElicitIntent</code> - The next action is to determine the intent that the user * wants to fulfill. * </li> * <li> * * <code>ElicitSlot</code> - The next action is to elicit a slot value from the * user. * </li> * </ul> */ type: DialogActionType | string | undefined; /** * The name of the intent. */ intentName?: string; /** * Map of the slots that have been gathered and their values. */ slots?: { [key: string]: string; }; /** * The name of the slot that should be elicited from the user. */ slotToElicit?: string; /** * The fulfillment state of the intent. The possible values are: * <ul> * <li> * * <code>Failed</code> - The Lambda function associated with the intent failed to fulfill * the intent. * </li> * <li> * * <code>Fulfilled</code> - The intent has fulfilled by the Lambda function associated * with the intent. * </li> * <li> * * <code>ReadyForFulfillment</code> - All of the information necessary for the intent is * present and the intent ready to be fulfilled by the client application. * </li> * </ul> */ fulfillmentState?: FulfillmentState | string; /** * The message that should be shown to the user. If you don't specify a message, Amazon Lex will * use the message configured for the intent. */ message?: string; /** * <ul> * <li> * * <code>PlainText</code> - The message contains plain UTF-8 text. * </li> * <li> * * <code>CustomPayload</code> - The message is a custom format for the client. * </li> * <li> * * <code>SSML</code> - The message contains text formatted for voice output. * </li> * <li> * * <code>Composite</code> - The message contains an escaped JSON object containing one or * more messages. For more information, see <a href="https://docs.aws.amazon.com/lex/latest/dg/howitworks-manage-prompts.html">Message * Groups</a>. * </li> * </ul> */ messageFormat?: MessageFormatType | string; } export declare namespace DialogAction { const filterSensitiveLog: (obj: DialogAction) => any; } export declare enum ConfirmationStatus { CONFIRMED = "Confirmed", DENIED = "Denied", NONE = "None" } /** * Provides information about the state of an intent. You can use this information to get the * current state of an intent so that you can process the intent, or so that you can return the * intent to its previous state. */ export interface IntentSummary { /** * The name of the intent. */ intentName?: string; /** * A user-defined label that identifies a particular intent. You can use this label to return * to a previous intent. * Use the <code>checkpointLabelFilter</code> parameter of the <code>GetSessionRequest</code> * operation to filter the intents returned by the operation to those with only the specified * label. */ checkpointLabel?: string; /** * Map of the slots that have been gathered and their values. */ slots?: { [key: string]: string; }; /** * The status of the intent after the user responds to the confirmation prompt. If the user * confirms the intent, Amazon Lex sets this field to <code>Confirmed</code>. If the user denies the * intent, Amazon Lex sets this value to <code>Denied</code>. The possible values are: * <ul> * <li> * * <code>Confirmed</code> - The user has responded "Yes" to the confirmation prompt, * confirming that the intent is complete and that it is ready to be fulfilled. * </li> * <li> * * <code>Denied</code> - The user has responded "No" to the confirmation prompt. * </li> * <li> * * <code>None</code> - The user has never been prompted for confirmation; or, the user * was prompted but did not confirm or deny the prompt. * </li> * </ul> */ confirmationStatus?: ConfirmationStatus | string; /** * The next action that the bot should take in its interaction with the user. The possible * values are: * <ul> * <li> * * <code>ConfirmIntent</code> - The next action is asking the user if the intent is * complete and ready to be fulfilled. This is a yes/no question such as "Place the * order?" * </li> * <li> * * <code>Close</code> - Indicates that the there will not be a response from the user. * For example, the statement "Your order has been placed" does not require a * response. * </li> * <li> * * <code>ElicitIntent</code> - The next action is to determine the intent that the user * wants to fulfill. * </li> * <li> * * <code>ElicitSlot</code> - The next action is to elicit a slot value from the * user. * </li> * </ul> */ dialogActionType: DialogActionType | string | undefined; /** * The fulfillment state of the intent. The possible values are: * <ul> * <li> * * <code>Failed</code> - The Lambda function associated with the intent failed to fulfill * the intent. * </li> * <li> * * <code>Fulfilled</code> - The intent has fulfilled by the Lambda function associated * with the intent. * </li> * <li> * * <code>ReadyForFulfillment</code> - All of the information necessary for the intent is * present and the intent ready to be fulfilled by the client application. * </li> * </ul> */ fulfillmentState?: FulfillmentState | string; /** * The next slot to elicit from the user. If there is not slot to elicit, the field is * blank. */ slotToElicit?: string; } export declare namespace IntentSummary { const filterSensitiveLog: (obj: IntentSummary) => any; } export interface GetSessionResponse { /** * An array of information about the intents used in the session. The array can contain a * maximum of three summaries. If more than three intents are used in the session, the * <code>recentIntentSummaryView</code> operation contains information about the last three * intents used. * If you set the <code>checkpointLabelFilter</code> parameter in the request, the array * contains only the intents with the specified label. */ recentIntentSummaryView?: IntentSummary[]; /** * Map of key/value pairs representing the session-specific context information. It contains * application information passed between Amazon Lex and a client application. */ sessionAttributes?: { [key: string]: string; }; /** * A unique identifier for the session. */ sessionId?: string; /** * Describes the current state of the bot. */ dialogAction?: DialogAction; /** * A list of active contexts for the session. A context can be set when an intent * is fulfilled or by calling the <code>PostContent</code>, <code>PostText</code>, * or <code>PutSession</code> operation. * You can use a context to control the intents that can follow up an intent, * or to modify the operation of your application. */ activeContexts?: ActiveContext[]; } export declare namespace GetSessionResponse { const filterSensitiveLog: (obj: GetSessionResponse) => any; } /** * Either the Amazon Lex bot is still building, or one of the dependent services (Amazon Polly, * AWS Lambda) failed with an internal service error. */ export interface BadGatewayException extends __SmithyException, $MetadataBearer { name: "BadGatewayException"; $fault: "server"; Message?: string; } export declare namespace BadGatewayException { const filterSensitiveLog: (obj: BadGatewayException) => any; } /** * One of the dependencies, such as AWS Lambda or Amazon Polly, threw an exception. For example, * <ul> * <li> * If Amazon Lex does not have sufficient permissions to call a Lambda function. * </li> * <li> * If a Lambda function takes longer than 30 seconds to execute. * </li> * <li> * If a fulfillment Lambda function returns a <code>Delegate</code> dialog action without * removing any slot values. * </li> * </ul> */ export interface DependencyFailedException extends __SmithyException, $MetadataBearer { name: "DependencyFailedException"; $fault: "client"; Message?: string; } export declare namespace DependencyFailedException { const filterSensitiveLog: (obj: DependencyFailedException) => any; } /** * This exception is not used. */ export interface LoopDetectedException extends __SmithyException, $MetadataBearer { name: "LoopDetectedException"; $fault: "server"; Message?: string; } export declare namespace LoopDetectedException { const filterSensitiveLog: (obj: LoopDetectedException) => any; } /** * The accept header in the request does not have a valid value. */ export interface NotAcceptableException extends __SmithyException, $MetadataBearer { name: "NotAcceptableException"; $fault: "client"; message?: string; } export declare namespace NotAcceptableException { const filterSensitiveLog: (obj: NotAcceptableException) => any; } export interface PostContentRequest { /** * Name of the Amazon Lex bot. */ botName: string | undefined; /** * Alias of the Amazon Lex bot. */ botAlias: string | undefined; /** * The ID of the client application user. Amazon Lex uses this to identify a user's conversation * with your bot. At runtime, each request must contain the <code>userID</code> field. * To decide the user ID to use for your application, consider the following factors. * <ul> * <li> * The <code>userID</code> field must not contain any personally identifiable information * of the user, for example, name, personal identification numbers, or other end user * personal information. * </li> * <li> * If you want a user to start a conversation on one device and continue on another * device, use a user-specific identifier. * </li> * <li> * If you want the same user to be able to have two independent conversations on two * different devices, choose a device-specific identifier. * </li> * <li> * A user can't have two independent conversations with two different versions of the * same bot. For example, a user can't have a conversation with the PROD and BETA versions of * the same bot. If you anticipate that a user will need to have conversation with two * different versions, for example, while testing, include the bot alias in the user ID to * separate the two conversations. * </li> * </ul> */ userId: string | undefined; /** * You pass this value as the <code>x-amz-lex-session-attributes</code> HTTP header. * Application-specific information passed between Amazon Lex and a client application. The value * must be a JSON serialized and base64 encoded map with string keys and values. The total size * of the <code>sessionAttributes</code> and <code>requestAttributes</code> headers is limited to * 12 KB. * For more information, see <a href="https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-session-attribs">Setting Session * Attributes</a>. */ sessionAttributes?: __LazyJsonString | string; /** * You pass this value as the <code>x-amz-lex-request-attributes</code> HTTP header. * Request-specific information passed between Amazon Lex and a client application. The value must * be a JSON serialized and base64 encoded map with string keys and values. The total size of the * <code>requestAttributes</code> and <code>sessionAttributes</code> headers is limited to 12 * KB. * The namespace <code>x-amz-lex:</code> is reserved for special attributes. Don't create any * request attributes with the prefix <code>x-amz-lex:</code>. * For more information, see <a href="https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-request-attribs">Setting Request * Attributes</a>. */ requestAttributes?: __LazyJsonString | string; /** * You pass this value as the <code>Content-Type</code> HTTP header. * Indicates the audio format or text. The header value must start with one of the following * prefixes: * <ul> * <li> * PCM format, audio data must be in little-endian byte order. * <ul> * <li> * audio/l16; rate=16000; channels=1 * </li> * <li> * audio/x-l16; sample-rate=16000; channel-count=1 * </li> * <li> * audio/lpcm; sample-rate=8000; sample-size-bits=16; channel-count=1; * is-big-endian=false * </li> * </ul> * </li> * <li> * Opus format * <ul> * <li> * audio/x-cbr-opus-with-preamble; preamble-size=0; bit-rate=256000; * frame-size-milliseconds=4 * </li> * </ul> * </li> * <li> * Text format * <ul> * <li> * text/plain; charset=utf-8 * </li> * </ul> * </li> * </ul> */ contentType: string | undefined; /** * You pass this value as the <code>Accept</code> HTTP header. * The message Amazon Lex returns in the response can be either text or speech based on the * <code>Accept</code> HTTP header value in the request. * <ul> * <li> * If the value is <code>text/plain; charset=utf-8</code>, Amazon Lex returns text in the * response. * </li> * <li> * If the value begins with <code>audio/</code>, Amazon Lex returns speech in the response. * Amazon Lex uses Amazon Polly to generate the speech (using the configuration you specified in the * <code>Accept</code> header). For example, if you specify <code>audio/mpeg</code> as the * value, Amazon Lex returns speech in the MPEG format. * </li> * <li> * If the value is <code>audio/pcm</code>, the speech returned is <code>audio/pcm</code> * in 16-bit, little endian format. * * </li> * <li> * The following are the accepted values: * <ul> * <li> * audio/mpeg * </li> * <li> * audio/ogg * </li> * <li> * audio/pcm * </li> * <li> * text/plain; charset=utf-8 * </li> * <li> * audio/* (defaults to mpeg) * </li> * </ul> * </li> * </ul> */ accept?: string; /** * User input in PCM or Opus audio format or text format as described in the * <code>Content-Type</code> HTTP header. * You can stream audio data to Amazon Lex or you can create a local buffer that captures all of * the audio data before sending. In general, you get better performance if you stream audio data * rather than buffering the data locally. */ inputStream: Readable | ReadableStream | Blob | undefined; /** * A list of contexts active for the request. A context can be activated when a previous * intent is fulfilled, or by including the context in the request, * If you don't specify a list of contexts, Amazon Lex will use the current list of contexts for * the session. If you specify an empty list, all contexts for the session are cleared. */ activeContexts?: __LazyJsonString | string; } export declare namespace PostContentRequest { const filterSensitiveLog: (obj: PostContentRequest) => any; } export declare enum DialogState { CONFIRM_INTENT = "ConfirmIntent", ELICIT_INTENT = "ElicitIntent", ELICIT_SLOT = "ElicitSlot", FAILED = "Failed", FULFILLED = "Fulfilled", READY_FOR_FULFILLMENT = "ReadyForFulfillment" } export interface PostContentResponse { /** * Content type as specified in the <code>Accept</code> HTTP header in the request. */ contentType?: string; /** * Current user intent that Amazon Lex is aware of. */ intentName?: string; /** * Provides a score that indicates how confident Amazon Lex is that the returned intent is the one * that matches the user's intent. The score is between 0.0 and 1.0. * The score is a relative score, not an absolute score. The score may change based on * improvements to Amazon Lex. */ nluIntentConfidence?: __LazyJsonString | string; /** * One to four alternative intents that may be applicable to the user's intent. * Each alternative includes a score that indicates how confident Amazon Lex is that the intent * matches the user's intent. The intents are sorted by the confidence score. */ alternativeIntents?: __LazyJsonString | string; /** * Map of zero or more intent slots (name/value pairs) Amazon Lex detected from the user input * during the conversation. The field is base-64 encoded. * Amazon Lex creates a resolution list containing likely values for a slot. The value that it * returns is determined by the <code>valueSelectionStrategy</code> selected when the slot type * was created or updated. If <code>valueSelectionStrategy</code> is set to * <code>ORIGINAL_VALUE</code>, the value provided by the user is returned, if the user value * is similar to the slot values. If <code>valueSelectionStrategy</code> is set to * <code>TOP_RESOLUTION</code> Amazon Lex returns the first value in the resolution list or, if * there is no resolution list, null. If you don't specify a <code>valueSelectionStrategy</code>, * the default is <code>ORIGINAL_VALUE</code>. */ slots?: __LazyJsonString | string; /** * Map of key/value pairs representing the session-specific context information. */ sessionAttributes?: __LazyJsonString | string; /** * The sentiment expressed in an utterance. * When the bot is configured to send utterances to Amazon Comprehend for sentiment analysis, * this field contains the result of the analysis. */ sentimentResponse?: string; /** * The message to convey to the user. The message can come from the bot's configuration or * from a Lambda function. * If the intent is not configured with a Lambda function, or if the Lambda function returned * <code>Delegate</code> as the <code>dialogAction.type</code> in its response, Amazon Lex decides * on the next course of action and selects an appropriate message from the bot's configuration * based on the current interaction context. For example, if Amazon Lex isn't able to understand user * input, it uses a clarification prompt message. * When you create an intent you can assign messages to groups. When messages are assigned to * groups Amazon Lex returns one message from each group in the response. The message field is an * escaped JSON string containing the messages. For more information about the structure of the * JSON string returned, see <a>msg-prompts-formats</a>. * If the Lambda function returns a message, Amazon Lex passes it to the client in its * response. */ message?: string; /** * The format of the response message. One of the following values: * <ul> * <li> * * <code>PlainText</code> - The message contains plain UTF-8 text. * </li> * <li> * * <code>CustomPayload</code> - The message is a custom format for the client. * </li> * <li> * * <code>SSML</code> - The message contains text formatted for voice output. * </li> * <li> * * <code>Composite</code> - The message contains an escaped JSON object containing one or * more messages from the groups that messages were assigned to when the intent was * created. * </li> * </ul> */ messageFormat?: MessageFormatType | string; /** * Identifies the current state of the user interaction. Amazon Lex returns one of the following * values as <code>dialogState</code>. The client can optionally use this information to * customize the user interface. * <ul> * <li> * * <code>ElicitIntent</code> - Amazon Lex wants to elicit the user's intent. Consider the * following examples: * For example, a user might utter an intent ("I want to order a pizza"). If Amazon Lex * cannot infer the user intent from this utterance, it will return this dialog state. * * </li> * <li> * * <code>ConfirmIntent</code> - Amazon Lex is expecting a "yes" or "no" response. * For example, Amazon Lex wants user confirmation before fulfilling an intent. Instead of a * simple "yes" or "no" response, a user might respond with additional information. For * example, "yes, but make it a thick crust pizza" or "no, I want to order a drink." Amazon Lex * can process such additional information (in these examples, update the crust type slot or * change the intent from OrderPizza to OrderDrink). * </li> * <li> * * <code>ElicitSlot</code> - Amazon Lex is expecting the value of a slot for the current intent. * For example, suppose that in the response Amazon Lex sends this message: "What size pizza * would you like?". A user might reply with the slot value (e.g., "medium"). The user might * also provide additional information in the response (e.g., "medium thick crust pizza"). * Amazon Lex can process such additional information appropriately. * </li> * <li> * * <code>Fulfilled</code> - Conveys that the Lambda function has successfully fulfilled the * intent. * </li> * <li> * * <code>ReadyForFulfillment</code> - Conveys that the client has to fulfill the request. * * </li> * <li> * * <code>Failed</code> - Conveys that the conversation with the user failed. * This can happen for various reasons, including that the user does not provide an * appropriate response to prompts from the service (you can configure how many times Amazon Lex * can prompt a user for specific information), or if the Lambda function fails to fulfill the * intent. * </li> * </ul> */ dialogState?: DialogState | string; /** * If the <code>dialogState</code> value is <code>ElicitSlot</code>, returns the name of the * slot for which Amazon Lex is eliciting a value. */ slotToElicit?: string; /** * The text used to process the request. * If the input was an audio stream, the <code>inputTranscript</code> field contains the text * extracted from the audio stream. This is the text that is actually processed to recognize * intents and slot values. You can use this information to determine if Amazon Lex is correctly * processing the audio that you send. */ inputTranscript?: string; /** * The prompt (or statement) to convey to the user. This is based on the bot configuration * and context. For example, if Amazon Lex did not understand the user intent, it sends the * <code>clarificationPrompt</code> configured for the bot. If the intent requires confirmation * before taking the fulfillment action, it sends the <code>confirmationPrompt</code>. Another * example: Suppose that the Lambda function successfully fulfilled the intent, and sent a message * to convey to the user. Then Amazon Lex sends that message in the response. */ audioStream?: Readable | ReadableStream | Blob; /** * The version of the bot that responded to the conversation. You can use this information to * help determine if one version of a bot is performing better than another version. */ botVersion?: string; /** * The unique identifier for the session. */ sessionId?: string; /** * A list of active contexts for the session. A context can be set when an intent * is fulfilled or by calling the <code>PostContent</code>, <code>PostText</code>, * or <code>PutSession</code> operation. * You can use a context to control the intents that can follow up an intent, * or to modify the operation of your application. */ activeContexts?: __LazyJsonString | string; } export declare namespace PostContentResponse { const filterSensitiveLog: (obj: PostContentResponse) => any; } /** * The input speech is too long. */ export interface RequestTimeoutException extends __SmithyException, $MetadataBearer { name: "RequestTimeoutException"; $fault: "client"; message?: string; } export declare namespace RequestTimeoutException { const filterSensitiveLog: (obj: RequestTimeoutException) => any; } /** * The Content-Type header (<code>PostContent</code> API) has an invalid value. */ export interface UnsupportedMediaTypeException extends __SmithyException, $MetadataBearer { name: "UnsupportedMediaTypeException"; $fault: "client"; message?: string; } export declare namespace UnsupportedMediaTypeException { const filterSensitiveLog: (obj: UnsupportedMediaTypeException) => any; } export interface PostTextRequest { /** * The name of the Amazon Lex bot. */ botName: string | undefined; /** * The alias of the Amazon Lex bot. */ botAlias: string | undefined; /** * The ID of the client application user. Amazon Lex uses this to identify a user's conversation * with your bot. At runtime, each request must contain the <code>userID</code> field. * To decide the user ID to use for your application, consider the following factors. * <ul> * <li> * The <code>userID</code> field must not contain any personally identifiable information * of the user, for example, name, personal identification numbers, or other end user * personal information. * </li> * <li> * If you want a user to start a conversation on one device and continue on another * device, use a user-specific identifier. * </li> * <li> * If you want the same user to be able to have two independent conversations on two * different devices, choose a device-specific identifier. * </li> * <li> * A user can't have two independent conversations with two different versions of the * same bot. For example, a user can't have a conversation with the PROD and BETA versions of * the same bot. If you anticipate that a user will need to have conversation with two * different versions, for example, while testing, include the bot alias in the user ID to * separate the two conversations. * </li> * </ul> */ userId: string | undefined; /** * Application-specific information passed between Amazon Lex and a client application. * For more information, see <a href="https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-session-attribs">Setting Session * Attributes</a>. */ sessionAttributes?: { [key: string]: string; }; /** * Request-specific information passed between Amazon Lex and a client application. * The namespace <code>x-amz-lex:</code> is reserved for special attributes. Don't create any * request attributes with the prefix <code>x-amz-lex:</code>. * For more information, see <a href="https://docs.aws.amazon.com/lex/latest/dg/context-mgmt.html#context-mgmt-request-attribs">Setting Request * Attributes</a>. */ requestAttributes?: { [key: string]: string; }; /** * The text that the user entered (Amazon Lex interprets this text). */ inputText: string | undefined; /** * A list of contexts active for the request. A context can be activated when a previous * intent is fulfilled, or by including the context in the request, * If you don't specify a list of contexts, Amazon Lex will use the current list of contexts for * the session. If you specify an empty list, all contexts for the session are cleared. */ activeContexts?: ActiveContext[]; } export declare namespace PostTextRequest { const filterSensitiveLog: (obj: PostTextRequest) => any; } /** * Provides a score that indicates the confidence that Amazon Lex has that an intent is the one * that satisfies the user's intent. */ export interface IntentConfidence { /** * A score that indicates how confident Amazon Lex is that an intent satisfies the user's intent. * Ranges between 0.00 and 1.00. Higher scores indicate higher confidence. */ score?: number; } export declare namespace IntentConfidence { const filterSensitiveLog: (obj: IntentConfidence) => any; } /** * An intent that Amazon Lex suggests satisfies the user's intent. Includes the name of the * intent, the confidence that Amazon Lex has that the user's intent is satisfied, and the slots * defined for the intent. */ export interface PredictedIntent { /** * The name of the intent that Amazon Lex suggests satisfies the user's intent. */ intentName?: string; /** * Indicates how confident Amazon Lex is that an intent satisfies the user's intent. */ nluIntentConfidence?: IntentConfidence; /** * The slot and slot values associated with the predicted intent. */ slots?: { [key: string]: string; }; } export declare namespace PredictedIntent { const filterSensitiveLog: (obj: PredictedIntent) => any; } export declare enum ContentType { GENERIC = "application/vnd.amazonaws.card.generic" } /** * Represents an option to be shown on the client platform (Facebook, Slack, etc.) */ export interface Button { /** * Text that is visible to the user on the button. */ text: string | undefined; /** * The value sent to Amazon Lex when a user chooses the button. For example, consider button * text "NYC." When the user chooses the button, the value sent can be "New York City." */ value: string | undefined; } export declare namespace Button { const filterSensitiveLog: (obj: Button) => any; } /** * Represents an option rendered to the user when a prompt is shown. It could be an image, a * button, a link, or text. */ export interface GenericAttachment { /** * The title of the option. */ title?: string; /** * The subtitle shown below the title. */ subTitle?: string; /** * The URL of an attachment to the response card. */ attachmentLinkUrl?: string; /** * The URL of an image that is displayed to the user. */ imageUrl?: string; /** * The list of options to show to the user. */ buttons?: Button[]; } export declare namespace GenericAttachment { const filterSensitiveLog: (obj: GenericAttachment) => any; } /** * If you configure a response card when creating your bots, Amazon Lex substitutes the session * attributes and slot values that are available, and then returns it. The response card can also * come from a Lambda function ( <code>dialogCodeHook</code> and <code>fulfillmentActivity</code> * on an intent). */ export interface ResponseCard { /** * The version of the response card format. */ version?: string; /** * The content type of the response. */ contentType?: ContentType | string; /** * An array of attachment objects representing options. */ genericAttachments?: GenericAttachment[]; } export declare namespace ResponseCard { const filterSensitiveLog: (obj: ResponseCard) => any; } /** * The sentiment expressed in an utterance. * When the bot is configured to send utterances to Amazon Comprehend for sentiment analysis, * this field structure contains the result of the analysis. */ export interface SentimentResponse { /** * The inferred sentiment that Amazon Comprehend has the highest confidence in. */ sentimentLabel?: string; /** * The likelihood that the sentiment was correctly inferred. */ sentimentScore?: string; } export declare namespace SentimentResponse { const filterSensitiveLog: (obj: SentimentResponse) => any; } export interface PostTextResponse { /** * The current user intent that Amazon Lex is aware of. */ intentName?: string; /** * Provides a score that indicates how confident Amazon Lex is that the returned intent is the one * that matches the user's intent. The score is between 0.0 and 1.0. For more information, see * <a href="https://docs.aws.amazon.com/lex/latest/dg/confidence-scores.html">Confidence * Scores</a>. * The score is a relative score, not an absolute score. The score may change based on * improvements to Amazon Lex. */ nluIntentConfidence?: IntentConfidence; /** * One to four alternative intents that may be applicable to the user's intent. * Each alternative includes a score that indicates how confident Amazon Lex is that the intent * matches the user's intent. The intents are sorted by the confidence score. */ alternativeIntents?: PredictedIntent[]; /** * The intent slots that Amazon Lex detected from the user input in the conversation. * Amazon Lex creates a resolution list containing likely values for a slot. The value that it * returns is determined by the <code>valueSelectionStrategy</code> selected when the slot type * was created or updated. If <code>valueSelectionStrategy</code> is set to * <code>ORIGINAL_VALUE</code>, the value provided by the user is returned, if the user value * is similar to the slot values. If <code>valueSelectionStrategy</code> is set to * <code>TOP_RESOLUTION</code> Amazon Lex returns the first value in the resolution list or, if * there is no resolution list, null. If you don't specify a <code>valueSelectionStrategy</code>, * the default is <code>ORIGINAL_VALUE</code>. */ slots?: { [key: string]: string; }; /** * A map of key-value pairs representing the session-specific context information. */ sessionAttributes?: { [key: string]: string; }; /** * The message to convey to the user. The message can come from the bot's configuration or * from a Lambda function. * If the intent is not configured with a Lambda function, or if the Lambda function returned * <code>Delegate</code> as the <code>dialogAction.type</code> its response, Amazon Lex decides on * the next course of action and selects an appropriate message from the bot's configuration * based on the current interaction context. For example, if Amazon Lex isn't able to understand user * input, it uses a clarification prompt message. * When you create an intent you can assign messages to groups. When messages are assigned to * groups Amazon Lex returns one message from each group in the response. The message field is an * escaped JSON string containing the messages. For more information about the structure of the * JSON string returned, see <a>msg-prompts-formats</a>. * If the Lambda function returns a message, Amazon Lex passes it to the client in its * response. */ message?: string; /** * The sentiment expressed in and utterance. * When the bot is configured to send utterances to Amazon Comprehend for sentiment analysis, * this field contains the result of the analysis. */ sentimentResponse?: SentimentResponse; /** * The format of the response message. One of the following values: * <ul> * <li> * * <code>PlainText</code> - The message cont