import { SENSITIVE_STRING } from "@aws-sdk/smithy-client" ; import { MetadataBearer as $MetadataBearer , SmithyException as __SmithyException } from "@aws-sdk/types" ; import { Readable } from "stream" ; /**
 * <p></p>
 */ export interface AccessDeniedException extends __SmithyException , $MetadataBearer { name : "AccessDeniedException" ; $fault : "client" ; message : string | undefined ; } /**
 * <p>The time that a context is active. You can specify the time to live
 *          in seconds or in conversation turns.</p>
 */ export interface ActiveContextTimeToLive { /**
     * <p>The number of seconds that the context is active. You can specify
     *          between 5 and 86400 seconds (24 hours).</p>
     */ timeToLiveInSeconds : number | undefined ; /**
     * <p>The number of turns that the context is active. You can specify up
     *          to 20 turns. Each request and response from the bot is a turn.</p>
     */ turnsToLive : number | undefined ; } export namespace ActiveContextTimeToLive { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } /**
 * <p>Contains information about the contexts that a user is using in a
 *          session. You can configure Amazon Lex V2 to set a context when an intent is
 *          fulfilled, or you can set a context using the , , or  operations.</p>
 *          <p>Use a context to indicate to Amazon Lex V2 intents that should be used as
 *          follow-up intents. For example, if the active context is
 *             <code>order-fulfilled</code>, only intents that have
 *             <code>order-fulfilled</code> configured as a trigger are considered
 *          for follow up.</p>
 */ export interface ActiveContext { /**
     * <p>The name of the context.</p>
     */ name : string | undefined ; /**
     * <p>Indicates the number of turns or seconds that the context is active.
     *          Once the time to live expires, the context is no longer returned in a
     *          response.</p>
     */ timeToLive : ActiveContextTimeToLive | undefined ; /**
     * <p>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.</p>
     *          <p>If you don't specify a list of contexts, Amazon Lex V2 will use the current
     *          list of contexts for the session. If you specify an empty list, all
     *          contexts for the session are cleared. </p>
     */ contextAttributes : { [ key ] : string ; } | undefined ; } export namespace ActiveContext { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , ... ( obj . contextAttributes && { contextAttributes : SENSITIVE_STRING } ) , } ) ; } /**
 * <p>Represents a chunk of audio sent from the client application to
 *          Amazon Lex V2. The audio is all or part of an utterance from the user.</p>
 *          <p>Amazon Lex V2 accumulates audio chunks until it recognizes a natural pause
 *          in speech before processing the input.</p>
 */ export interface AudioInputEvent { /**
     * <p>An encoded stream of audio.</p>
     */ audioChunk ? : Uint8Array ; /**
     * <p>The encoding used for the audio chunk. You must use 8 KHz PCM 16-bit
     *          mono-channel little-endian format. The value of the field should
     *          be:</p>
     *          <p>
     *             <code>audio/lpcm; sample-rate=8000; sample-size-bits=16;
     *             channel-count=1; is-big-endian=false</code>
     *          </p>
     */ contentType : string | undefined ; /**
     * <p>A unique identifier that your application assigns to the event. You
     *          can use this to identify events in logs.</p>
     */ eventId ? : string ; /**
     * <p>A timestamp set by the client of the date and time that the event
     *          was sent to Amazon Lex V2.</p>
     */ clientTimestampMillis ? : number ; } export namespace AudioInputEvent { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } /**
 * <p>An event sent from Amazon Lex V2 to your client application containing audio
 *          to play to the user. </p>
 */ export interface AudioResponseEvent { /**
     * <p>A chunk of the audio to play. </p>
     */ audioChunk ? : Uint8Array ; /**
     * <p>The encoding of the audio chunk. This is the same as the encoding
     *          configure in the <code>contentType</code> field of the
     *             <code>ConfigurationEvent</code>.</p>
     */ contentType ? : string ; /**
     * <p>A unique identifier of the event sent by Amazon Lex V2. The identifier is in
     *          the form <code>RESPONSE-N</code>, where N is a number starting with one
     *          and incremented for each event sent by Amazon Lex V2 in the current
     *          session.</p>
     */ eventId ? : string ; } export namespace AudioResponseEvent { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } /**
 * <p></p>
 */ export interface ConflictException extends __SmithyException , $MetadataBearer { name : "ConflictException" ; $fault : "client" ; message : string | undefined ; } export interface DeleteSessionRequest { /**
     * <p>The identifier of the bot that contains the session data.</p>
     */ botId : string | undefined ; /**
     * <p>The alias identifier in use for the bot that contains the session
     *          data.</p>
     */ botAliasId : string | undefined ; /**
     * <p>The locale where the session is in use.</p>
     */ localeId : string | undefined ; /**
     * <p>The identifier of the session to delete.</p>
     */ sessionId : string | undefined ; } export namespace DeleteSessionRequest { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } export interface DeleteSessionResponse { /**
     * <p>The identifier of the bot that contained the session data.</p>
     */ botId ? : string ; /**
     * <p>The alias identifier in use for the bot that contained the session
     *          data.</p>
     */ botAliasId ? : string ; /**
     * <p>The locale where the session was used.</p>
     */ localeId ? : string ; /**
     * <p>The identifier of the deleted session.</p>
     */ sessionId ? : string ; } export namespace DeleteSessionResponse { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } /**
 * <p></p>
 */ export interface InternalServerException extends __SmithyException , $MetadataBearer { name : "InternalServerException" ; $fault : "server" ; message : string | undefined ; } /**
 * <p></p>
 */ export interface ResourceNotFoundException extends __SmithyException , $MetadataBearer { name : "ResourceNotFoundException" ; $fault : "client" ; message : string | undefined ; } /**
 * <p></p>
 */ export interface ThrottlingException extends __SmithyException , $MetadataBearer { name : "ThrottlingException" ; $fault : "client" ; message : string | undefined ; } /**
 * <p></p>
 */ export interface ValidationException extends __SmithyException , $MetadataBearer { name : "ValidationException" ; $fault : "client" ; message : string | undefined ; } export interface GetSessionRequest { /**
     * <p>The identifier of the bot that contains the session data.</p>
     */ botId : string | undefined ; /**
     * <p>The alias identifier in use for the bot that contains the session
     *          data.</p>
     */ botAliasId : string | undefined ; /**
     * <p>The locale where the session is in use.</p>
     */ localeId : string | undefined ; /**
     * <p>The identifier of the session to return.</p>
     */ sessionId : string | undefined ; } export namespace GetSessionRequest { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } export enum ConfirmationState { CONFIRMED = "Confirmed" , DENIED = "Denied" , NONE = "None" } export enum Shape { LIST = "List" , SCALAR = "Scalar" } /**
 * <p>The value of a slot.</p>
 */ export interface Value { /**
     * <p>The text of the utterance from the user that was entered for the
     *          slot.</p>
     */ originalValue ? : string ; /**
     * <p>The value that Amazon Lex V2 determines for the slot. The actual value
     *          depends on the setting of the value selection strategy for the bot. You
     *          can choose to use the value entered by the user, or you can have Amazon Lex V2
     *          choose the first value in the <code>resolvedValues</code> list.</p>
     */ interpretedValue : string | undefined ; /**
     * <p>A list of additional values that have been recognized for the
     *          slot.</p>
     */ resolvedValues ? : string [ ] ; } export namespace Value { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } export enum IntentState { FAILED = "Failed" , FULFILLED = "Fulfilled" , FULFILLMENT_IN_PROGRESS = "FulfillmentInProgress" , IN_PROGRESS = "InProgress" , READY_FOR_FULFILLMENT = "ReadyForFulfillment" , WAITING = "Waiting" } /**
 * <p>Provides a score that indicates the confidence that Amazon Lex V2 has that
 *          an intent is the one that satisfies the user's intent.</p>
 */ export interface ConfidenceScore { /**
     * <p>A score that indicates how confident Amazon Lex V2 is that an intent
     *          satisfies the user's intent. Ranges between 0.00 and 1.00. Higher
     *          scores indicate higher confidence.</p>
     */ score ? : number ; } export namespace ConfidenceScore { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } export enum SentimentType { MIXED = "MIXED" , NEGATIVE = "NEGATIVE" , NEUTRAL = "NEUTRAL" , POSITIVE = "POSITIVE" } /**
 * <p>The individual sentiment responses for the utterance.</p>
 */ export interface SentimentScore { /**
     * <p>The level of confidence that Amazon Comprehend has in the accuracy
     *          of its detection of the <code>POSITIVE</code> sentiment.</p>
     */ positive ? : number ; /**
     * <p>The level of confidence that Amazon Comprehend has in the accuracy
     *          of its detection of the <code>NEGATIVE</code> sentiment.</p>
     */ negative ? : number ; /**
     * <p>The level of confidence that Amazon Comprehend has in the accuracy
     *          of its detection of the <code>NEUTRAL</code> sentiment.</p>
     */ neutral ? : number ; /**
     * <p>The level of confidence that Amazon Comprehend has in the accuracy
     *          of its detection of the <code>MIXED</code> sentiment.</p>
     */ mixed ? : number ; } export namespace SentimentScore { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } /**
 * <p>Provides information about the sentiment expressed in a user's
 *          response in a conversation. Sentiments are determined using Amazon
 *          Comprehend. Sentiments are only returned if they are enabled for the
 *          bot.</p>
 *          <p>For more information, see <a href="https://docs.aws.amazon.com/comprehend/latest/dg/how-sentiment.html">
 *             Determine Sentiment </a> in the <i>Amazon Comprehend
 *             developer guide</i>.</p>
 */ export interface SentimentResponse { /**
     * <p>The overall sentiment expressed in the user's response. This is the
     *          sentiment most likely expressed by the user based on the analysis by
     *          Amazon Comprehend.</p>
     */ sentiment ? : SentimentType | string ; /**
     * <p>The individual sentiment responses for the utterance.</p>
     */ sentimentScore ? : SentimentScore ; } export namespace SentimentResponse { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } export enum MessageContentType { CUSTOM_PAYLOAD = "CustomPayload" , IMAGE_RESPONSE_CARD = "ImageResponseCard" , PLAIN_TEXT = "PlainText" , SSML = "SSML" } /**
 * <p>A button that appears on a response card show to the user.</p>
 */ export interface Button { /**
     * <p>The text that is displayed on the button.</p>
     */ text : string | undefined ; /**
     * <p>The value returned to Amazon Lex V2 when a user chooses the button.</p>
     */ value : string | undefined ; } export namespace Button { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } /**
 * <p>A card that is shown to the user by a messaging platform. You define
 *          the contents of the card, the card is displayed by the platform. </p>
 *          <p>When you use a response card, the response from the user is
 *          constrained to the text associated with a button on the card.</p>
 */ export interface ImageResponseCard { /**
     * <p>The title to display on the response card. The format of the title
     *          is determined by the platform displaying the response card.</p>
     */ title : string | undefined ; /**
     * <p>The subtitle to display on the response card. The format of the
     *          subtitle is determined by the platform displaying the response
     *          card.</p>
     */ subtitle ? : string ; /**
     * <p>The URL of an image to display on the response card. The image URL
     *          must be publicly available so that the platform displaying the response
     *          card has access to the image.</p>
     */ imageUrl ? : string ; /**
     * <p>A list of buttons that should be displayed on the response card. The
     *          arrangement of the buttons is determined by the platform that displays
     *          the button.</p>
     */ buttons ? : Button [ ] ; } export namespace ImageResponseCard { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } /**
 * <p>Container for text that is returned to the customer..</p>
 */ export interface Message { /**
     * <p>The text of the message.</p>
     */ content ? : string ; /**
     * <p>Indicates the type of response.</p>
     */ contentType : MessageContentType | string | undefined ; /**
     * <p>A card that is shown to the user by a messaging platform. You define
     *          the contents of the card, the card is displayed by the platform. </p>
     *          <p>When you use a response card, the response from the user is
     *          constrained to the text associated with a button on the card.</p>
     */ imageResponseCard ? : ImageResponseCard ; } export namespace Message { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , ... ( obj . content && { content : SENSITIVE_STRING } ) , } ) ; } export enum StyleType { DEFAULT = "Default" , SPELL_BY_LETTER = "SpellByLetter" , SPELL_BY_WORD = "SpellByWord" } export enum DialogActionType { CLOSE = "Close" , CONFIRM_INTENT = "ConfirmIntent" , DELEGATE = "Delegate" , ELICIT_INTENT = "ElicitIntent" , ELICIT_SLOT = "ElicitSlot" , NONE = "None" } /**
 * <p>The next action that Amazon Lex V2 should take.</p>
 */ export interface DialogAction { /**
     * <p>The next action that the bot should take in its interaction with the
     *          user. The possible values are:</p>
     *          <ul>
     *             <li>
     *                <p>
     *                   <code>Close</code> - Indicates that there will not be a
     *                response from the user. For example, the statement "Your order
     *                has been placed" does not require a response.</p>
     *             </li>
     *             <li>
     *                <p>
     *                   <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?"</p>
     *             </li>
     *             <li>
     *                <p>
     *                   <code>Delegate</code> - The next action is determined by
     *                Amazon Lex V2.</p>
     *             </li>
     *             <li>
     *                <p>
     *                   <code>ElicitSlot</code> - The next action is to elicit a slot
     *                value from the user.</p>
     *             </li>
     *          </ul>
     */ type : DialogActionType | string | undefined ; /**
     * <p>The name of the slot that should be elicited from the user.</p>
     */ slotToElicit ? : string ; /**
     * <p>Configures the slot to use spell-by-letter or spell-by-word style.
     *          When you use a style on a slot, users can spell out their input to make
     *          it clear to your bot.</p>
     *          <ul>
     *             <li>
     *                <p>Spell by letter - "b" "o" "b"</p>
     *             </li>
     *             <li>
     *                <p>Spell by word - "b as in boy" "o as in oscar" "b as in
     *                boy"</p>
     *             </li>
     *          </ul>
     *          <p>For more information, see <a href="https://docs.aws.amazon.com/lexv2/latest/dg/using-spelling.html">
     *             Using spelling to enter slot values </a>.</p>
     */ slotElicitationStyle ? : StyleType | string ; } export namespace DialogAction { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } /**
 * <p></p>
 */ export interface BadGatewayException extends __SmithyException , $MetadataBearer { name : "BadGatewayException" ; $fault : "server" ; message : string | undefined ; } /**
 * <p></p>
 */ export interface DependencyFailedException extends __SmithyException , $MetadataBearer { name : "DependencyFailedException" ; $fault : "client" ; message : string | undefined ; } export interface PutSessionResponse { /**
     * <p>The type of response. Same as the type specified in the
     *             <code>responseContentType</code> field in the request.</p>
     */ contentType ? : string ; /**
     * <p>A list of messages that were last sent to the user. The messages are
     *          ordered based on how you return the messages from you Lambda function
     *          or the order that the messages are defined in the bot.</p>
     */ messages ? : string ; /**
     * <p>Represents the current state of the dialog between the user and the
     *          bot.</p>
     *          <p>Use this to determine the progress of the conversation and what the
     *          next action may be.</p>
     */ sessionState ? : string ; /**
     * <p>Request-specific information passed between the client application
     *          and Amazon Lex V2. These are the same as the <code>requestAttribute</code>
     *          parameter in the call to the <code>PutSession</code> operation.</p>
     */ requestAttributes ? : string ; /**
     * <p>The identifier of the session that received the data.</p>
     */ sessionId ? : string ; /**
     * <p>If the requested content type was audio, the audio version of the
     *          message to convey to the user.</p>
     */ audioStream ? : Readable | ReadableStream | Blob ; } export namespace PutSessionResponse { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } export interface RecognizeUtteranceRequest { /**
     * <p>The identifier of the bot that should receive the request.</p>
     */ botId : string | undefined ; /**
     * <p>The alias identifier in use for the bot that should receive the
     *          request.</p>
     */ botAliasId : string | undefined ; /**
     * <p>The locale where the session is in use.</p>
     */ localeId : string | undefined ; /**
     * <p>The identifier of the session in use.</p>
     */ sessionId : string | undefined ; /**
     * <p>Sets the state of the session with the user. You can use this to set
     *          the current intent, attributes, context, and dialog action. Use the
     *          dialog action to determine the next step that Amazon Lex V2 should use in the
     *          conversation with the user.</p>
     *          <p>The <code>sessionState</code> field must be compressed using gzip
     *          and then base64 encoded before sending to Amazon Lex V2.</p>
     */ sessionState ? : string ; /**
     * <p>Request-specific information passed between the client application
     *          and Amazon Lex V2 </p>
     *          <p>The namespace <code>x-amz-lex:</code> is reserved for special
     *          attributes. Don't create any request attributes for prefix
     *             <code>x-amz-lex:</code>.</p>
     *          <p>The <code>requestAttributes</code> field must be compressed using
     *          gzip and then base64 encoded before sending to Amazon Lex V2.</p>
     */ requestAttributes ? : string ; /**
     * <p>Indicates the format for audio input or that the content is text.
     *          The header must start with one of the following prefixes:</p>
     *          <ul>
     *             <li>
     *                <p>PCM format, audio data must be in little-endian byte
     *                order.</p>
     *                <ul>
     *                   <li>
     *                      <p>audio/l16; rate=16000; channels=1</p>
     *                   </li>
     *                   <li>
     *                      <p>audio/x-l16; sample-rate=16000; channel-count=1</p>
     *                   </li>
     *                   <li>
     *                      <p>audio/lpcm; sample-rate=8000; sample-size-bits=16;
     *                      channel-count=1; is-big-endian=false</p>
     *                   </li>
     *                </ul>
     *             </li>
     *             <li>
     *                <p>Opus format</p>
     *                <ul>
     *                   <li>
     *                      <p>audio/x-cbr-opus-with-preamble;preamble-size=0;bit-rate=256000;frame-size-milliseconds=4</p>
     *                   </li>
     *                </ul>
     *             </li>
     *             <li>
     *                <p>Text format</p>
     *                <ul>
     *                   <li>
     *                      <p>text/plain; charset=utf-8</p>
     *                   </li>
     *                </ul>
     *             </li>
     *          </ul>
     */ requestContentType : string | undefined ; /**
     * <p>The message that Amazon Lex V2 returns in the response can be either text or
     *          speech based on the <code>responseContentType</code> value.</p>
     *          <ul>
     *             <li>
     *                <p>If the value is <code>text/plain;charset=utf-8</code>, Amazon Lex V2
     *                returns text in the response.</p>
     *             </li>
     *             <li>
     *                <p>If the value begins with <code>audio/</code>, Amazon Lex V2 returns
     *                speech in the response. Amazon Lex V2 uses Amazon Polly to generate the speech
     *                using the configuration that you specified in the
     *                   <code>requestContentType</code> parameter. For example, if you
     *                specify <code>audio/mpeg</code> as the value, Amazon Lex V2 returns
     *                speech in the MPEG format.</p>
     *             </li>
     *             <li>
     *                <p>If the value is <code>audio/pcm</code>, the speech returned is
     *                   <code>audio/pcm</code> at 16 KHz in 16-bit, little-endian
     *                format.</p>
     *             </li>
     *             <li>
     *                <p>The following are the accepted values:</p>
     *                <ul>
     *                   <li>
     *                      <p>audio/mpeg</p>
     *                   </li>
     *                   <li>
     *                      <p>audio/ogg</p>
     *                   </li>
     *                   <li>
     *                      <p>audio/pcm (16 KHz)</p>
     *                   </li>
     *                   <li>
     *                      <p>audio/* (defaults to mpeg)</p>
     *                   </li>
     *                   <li>
     *                      <p>text/plain; charset=utf-8</p>
     *                   </li>
     *                </ul>
     *             </li>
     *          </ul>
     */ responseContentType ? : string ; /**
     * <p>User input in PCM or Opus audio format or text format as described
     *          in the <code>requestContentType</code> parameter.</p>
     */ inputStream ? : Readable | ReadableStream | Blob ; } export namespace RecognizeUtteranceRequest { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , ... ( obj . sessionState && { sessionState : SENSITIVE_STRING } ) , ... ( obj . requestAttributes && { requestAttributes : SENSITIVE_STRING } ) , } ) ; } export interface RecognizeUtteranceResponse { /**
     * <p>Indicates whether the input mode to the operation was text or
     *          speech.
     *       </p>
     */ inputMode ? : string ; /**
     * <p>Content type as specified in the <code>responseContentType</code> in
     *          the request.</p>
     */ contentType ? : string ; /**
     * <p>A list of messages that were last sent to the user. The messages are
     *          ordered based on the order that you returned the messages from your
     *          Lambda function or the order that the messages are defined in the
     *          bot.</p>
     *          <p>The <code>messages</code> field is compressed with gzip and then
     *          base64 encoded. Before you can use the contents of the field, you must
     *          decode and decompress the contents. See the example for a simple
     *          function to decode and decompress the contents.</p>
     */ messages ? : string ; /**
     * <p>A list of intents that Amazon Lex V2 determined might satisfy the user's
     *          utterance.</p>
     *          <p>Each interpretation includes the intent, a score that indicates how
     *          confident Amazon Lex V2 is that the interpretation is the correct one, and an
     *          optional sentiment response that indicates the sentiment expressed in
     *          the utterance.</p>
     *          <p>The <code>interpretations</code> field is compressed with gzip and
     *          then base64 encoded. Before you can use the contents of the field, you
     *          must decode and decompress the contents. See the example for a simple
     *          function to decode and decompress the contents.</p>
     */ interpretations ? : string ; /**
     * <p>Represents the current state of the dialog between the user and the
     *          bot.</p>
     *          <p>Use this to determine the progress of the conversation and what the
     *          next action might be.</p>
     *          <p>The <code>sessionState</code> field is compressed with gzip and then
     *          base64 encoded. Before you can use the contents of the field, you must
     *          decode and decompress the contents. See the example for a simple
     *          function to decode and decompress the contents.</p>
     */ sessionState ? : string ; /**
     * <p>The attributes sent in the request.</p>
     *          <p>The <code>requestAttributes</code> field is compressed with gzip and
     *          then base64 encoded. Before you can use the contents of the field, you
     *          must decode and decompress the contents.</p>
     */ requestAttributes ? : string ; /**
     * <p>The identifier of the session in use.</p>
     */ sessionId ? : string ; /**
     * <p>The text used to process the request.</p>
     *          <p>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 V2 is correctly
     *          processing the audio that you send.</p>
     *          <p>The <code>inputTranscript</code> field is compressed with gzip and
     *          then base64 encoded. Before you can use the contents of the field, you
     *          must decode and decompress the contents. See the example for a simple
     *          function to decode and decompress the contents.</p>
     */ inputTranscript ? : string ; /**
     * <p>The prompt or statement to send to the user. This is based on the
     *          bot configuration and context. For example, if Amazon Lex V2 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 V2 sends that message in the
     *          response.</p>
     */ audioStream ? : Readable | ReadableStream | Blob ; } export namespace RecognizeUtteranceResponse { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } export enum ConversationMode { AUDIO = "AUDIO" , TEXT = "TEXT" } /**
 * <p>A notification from the client that it is disconnecting from Amazon Lex V2.
 *          Sending a <code>DisconnectionEvent</code> event is optional, but can
 *          help identify a conversation in logs.</p>
 */ export interface DisconnectionEvent { /**
     * <p>A unique identifier that your application assigns to the event. You
     *          can use this to identify events in logs.</p>
     */ eventId ? : string ; /**
     * <p>A timestamp set by the client of the date and time that the event
     *          was sent to Amazon Lex V2.</p>
     */ clientTimestampMillis ? : number ; } export namespace DisconnectionEvent { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } /**
 * <p>A DTMF character sent from the client application. DTMF characters
 *          are typically sent from a phone keypad to represent numbers. For
 *          example, you can have Amazon Lex V2 process a credit card number input from a
 *          phone.</p>
 */ export interface DTMFInputEvent { /**
     * <p>The DTMF character that the user pressed. The allowed characters are
     *          A - D, 0 - 9, # and *.</p>
     */ inputCharacter : string | undefined ; /**
     * <p>A unique identifier that your application assigns to the event. You
     *          can use this to identify events in logs.</p>
     */ eventId ? : string ; /**
     * <p>A timestamp set by the client of the date and time that the event
     *          was sent to Amazon Lex V2.</p>
     */ clientTimestampMillis ? : number ; } export namespace DTMFInputEvent { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , ... ( obj . inputCharacter && { inputCharacter : SENSITIVE_STRING } ) , } ) ; } /**
 * <p>Event sent from the client application to Amazon Lex V2 to indicate that
 *          playback of audio is complete and that Amazon Lex V2 should start processing
 *          the user's input.</p>
 */ export interface PlaybackCompletionEvent { /**
     * <p>A unique identifier that your application assigns to the event. You
     *          can use this to identify events in logs.</p>
     */ eventId ? : string ; /**
     * <p>A timestamp set by the client of the date and time that the event
     *          was sent to Amazon Lex V2.</p>
     */ clientTimestampMillis ? : number ; } export namespace PlaybackCompletionEvent { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } /**
 * <p>The event sent from your client application to Amazon Lex V2 with text input
 *          from the user.</p>
 */ export interface TextInputEvent { /**
     * <p>The text from the user. Amazon Lex V2 processes this as a complete
     *          statement.</p>
     */ text : string | undefined ; /**
     * <p>A unique identifier that your application assigns to the event. You
     *          can use this to identify events in logs.</p>
     */ eventId ? : string ; /**
     * <p>A timestamp set by the client of the date and time that the event
     *          was sent to Amazon Lex V2.</p>
     */ clientTimestampMillis ? : number ; } export namespace TextInputEvent { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , ... ( obj . text && { text : SENSITIVE_STRING } ) , } ) ; } /**
 * <p>Event that Amazon Lex V2 sends to indicate that the stream is still open
 *          between the client application and Amazon Lex V2 </p>
 */ export interface HeartbeatEvent { /**
     * <p>A unique identifier of the event sent by Amazon Lex V2. The identifier is in
     *          the form <code>RESPONSE-N</code>, where N is a number starting with one
     *          and incremented for each event sent by Amazon Lex V2 in the current
     *          session.</p>
     */ eventId ? : string ; } export namespace HeartbeatEvent { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } export enum InputMode { DTMF = "DTMF" , SPEECH = "Speech" , TEXT = "Text" } export enum PlaybackInterruptionReason { DTMF_START_DETECTED = "DTMF_START_DETECTED" , TEXT_DETECTED = "TEXT_DETECTED" , VOICE_START_DETECTED = "VOICE_START_DETECTED" } /**
 * <p>Event sent from Amazon Lex V2 to indicate to the client application should
 *          stop playback of audio. For example, if the client is playing a prompt
 *          that asks for the user's telephone number, the user might start to say
 *          the phone number before the prompt is complete. Amazon Lex V2 sends this event
 *          to the client application to indicate that the user is responding and
 *          that Amazon Lex V2 is processing their input.</p>
 */ export interface PlaybackInterruptionEvent { /**
     * <p>Indicates the type of user input that Amazon Lex V2 detected.</p>
     */ eventReason ? : PlaybackInterruptionReason | string ; /**
     * <p>The identifier of the event that contained the audio, DTMF, or text
     *          that caused the interruption.</p>
     */ causedByEventId ? : string ; /**
     * <p>A unique identifier of the event sent by Amazon Lex V2. The identifier is in
     *          the form <code>RESPONSE-N</code>, where N is a number starting with one
     *          and incremented for each event sent by Amazon Lex V2 in the current
     *          session.</p>
     */ eventId ? : string ; } export namespace PlaybackInterruptionEvent { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } /**
 * <p>The event sent from Amazon Lex V2 to your application with text to present
 *          to the user.</p>
 */ export interface TextResponseEvent { /**
     * <p>A list of messages to send to the user. Messages are ordered based
     *          on the order that you returned the messages from your Lambda function
     *          or the order that the messages are defined in the bot.</p>
     */ messages ? : Message [ ] ; /**
     * <p>A unique identifier of the event sent by Amazon Lex V2. The identifier is in
     *          the form <code>RESPONSE-N</code>, where N is a number starting with one
     *          and incremented for each event sent by Amazon Lex V2 in the current
     *          session.</p>
     */ eventId ? : string ; } export namespace TextResponseEvent { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , ... ( obj . messages && { messages : obj . messages . map ( ( item ) => Message . filterSensitiveLog ( item ) ) } ) , } ) ; } /**
 * <p>Event sent from Amazon Lex V2 to your client application that contains a
 *          transcript of voice audio. </p>
 */ export interface TranscriptEvent { /**
     * <p>The transcript of the voice audio from the user.</p>
     */ transcript ? : string ; /**
     * <p>A unique identifier of the event sent by Amazon Lex V2. The identifier is in
     *          the form <code>RESPONSE-N</code>, where N is a number starting with one
     *          and incremented for each event sent by Amazon Lex V2 in the current
     *          session.</p>
     */ eventId ? : string ; } export namespace TranscriptEvent { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } /**
 * <p>A value that Amazon Lex V2 uses to fulfill an intent. </p>
 */ export interface Slot { /**
     * <p>The current value of the slot.</p>
     */ value ? : Value ; /**
     * <p>When the <code>shape</code> value is <code>List</code>, it indicates
     *          that the <code>values</code> field contains a list of slot values. When
     *          the value is <code>Scalar</code>, it indicates that the
     *             <code>value</code> field contains a single value.</p>
     */ shape ? : Shape | string ; /**
     * <p>A list of one or more values that the user provided for the slot.
     *          For example, if a for a slot that elicits pizza toppings, the values
     *          might be "pepperoni" and "pineapple." </p>
     */ values ? : Slot [ ] ; } export namespace Slot { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } /**
 * <p>The current intent that Amazon Lex V2 is attempting to fulfill.</p>
 */ export interface Intent { /**
     * <p>The name of the intent.</p>
     */ name : string | undefined ; /**
     * <p>A map of all of the slots for the intent. The name of the slot maps
     *          to the value of the slot. If a slot has not been filled, the value is
     *          null.</p>
     */ slots ? : { [ key ] : Slot ; } ; /**
     * <p>Contains fulfillment information for the intent. </p>
     */ state ? : IntentState | string ; /**
     * <p>Contains information about whether fulfillment of the intent has
     *          been confirmed.</p>
     */ confirmationState ? : ConfirmationState | string ; } export namespace Intent { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } /**
 * <p>An intent that Amazon Lex V2 determined might satisfy the user's utterance.
 *          The intents are ordered by the confidence score. </p>
 */ export interface Interpretation { /**
     * <p>Determines the threshold where Amazon Lex V2 will insert the
     *             <code>AMAZON.FallbackIntent</code>,
     *             <code>AMAZON.KendraSearchIntent</code>, or both when returning
     *          alternative intents in a response. <code>AMAZON.FallbackIntent</code>
     *          and <code>AMAZON.KendraSearchIntent</code> are only inserted if they
     *          are configured for the bot.</p>
     */ nluConfidence ? : ConfidenceScore ; /**
     * <p>The sentiment expressed in an utterance. </p>
     *          <p>When the bot is configured to send utterances to Amazon Comprehend
     *          for sentiment analysis, this field contains the result of the
     *          analysis.</p>
     */ sentimentResponse ? : SentimentResponse ; /**
     * <p>A list of intents that might satisfy the user's utterance. The
     *          intents are ordered by the confidence score.</p>
     */ intent ? : Intent ; } export namespace Interpretation { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } /**
 * <p>The state of the user's session with Amazon Lex V2.</p>
 */ export interface SessionState { /**
     * <p>The next step that Amazon Lex V2 should take in the conversation with a
     *          user.</p>
     */ dialogAction ? : DialogAction ; /**
     * <p>The active intent that Amazon Lex V2 is processing.</p>
     */ intent ? : Intent ; /**
     * <p>One or more contexts that indicate to Amazon Lex V2 the context of a
     *          request. When a context is active, Amazon Lex V2 considers intents with the
     *          matching context as a trigger as the next intent in a session.</p>
     */ activeContexts ? : ActiveContext [ ] ; /**
     * <p>Map of key/value pairs representing session-specific context
     *          information. It contains application information passed between Amazon Lex V2
     *          and a client application.</p>
     */ sessionAttributes ? : { [ key ] : string ; } ; /**
     * <p></p>
     */ originatingRequestId ? : string ; } export namespace SessionState { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , ... ( obj . activeContexts && { activeContexts : obj . activeContexts . map ( ( item ) => ActiveContext . filterSensitiveLog ( item ) ) , } ) , } ) ; } /**
 * <p>The initial event sent from the application to Amazon Lex V2 to configure
 *          the conversation, including session and request attributes and the
 *          response content type.</p>
 */ export interface ConfigurationEvent { /**
     * <p>Request-specific information passed between the client application
     *          and Amazon Lex V2.</p>
     *          <p>The namespace <code>x-amz-lex:</code> is reserved for special
     *          attributes. Don't create any request attributes for prefix
     *             <code>x-amz-lex:</code>.</p>
     */ requestAttributes ? : { [ key ] : string ; } ; /**
     * <p>The message that Amazon Lex V2 returns in the response can be either text or
     *          speech based on the <code>responseContentType</code> value.</p>
     *          <ul>
     *             <li>
     *                <p>If the value is <code>text/plain;charset=utf-8</code>, Amazon Lex V2
     *                returns text in the response.</p>
     *             </li>
     *             <li>
     *                <p>If the value begins with <code>audio/</code>, Amazon Lex V2 returns
     *                speech in the response. Amazon Lex V2 uses Amazon Polly to generate the speech
     *                using the configuration that you specified in the
     *                   <code>requestContentType</code> parameter. For example, if you
     *                specify <code>audio/mpeg</code> as the value, Amazon Lex V2 returns
     *                speech in the MPEG format.</p>
     *             </li>
     *             <li>
     *                <p>If the value is <code>audio/pcm</code>, the speech returned is
     *                audio/pcm in 16-bit, little-endian format.</p>
     *             </li>
     *             <li>
     *                <p>The following are the accepted values:</p>
     *                <ul>
     *                   <li>
     *                      <p>audio/mpeg</p>
     *                   </li>
     *                   <li>
     *                      <p>audio/ogg</p>
     *                   </li>
     *                   <li>
     *                      <p>audio/pcm</p>
     *                   </li>
     *                   <li>
     *                      <p>audio/* (defaults to mpeg)</p>
     *                   </li>
     *                   <li>
     *                      <p>text/plain; charset=utf-8</p>
     *                   </li>
     *                </ul>
     *             </li>
     *          </ul>
     */ responseContentType : string | undefined ; /**
     * <p>The state of the user's session with Amazon Lex V2.</p>
     */ sessionState ? : SessionState ; /**
     * <p>A list of messages to send to the user.</p>
     */ welcomeMessages ? : Message [ ] ; /**
     * <p>Determines whether Amazon Lex V2 should send audio responses to the client
     *          application.
     *       </p>
     *          <p>Set this field to false when the client is operating in a playback
     *          mode where audio responses are played to the user. If the client isn't
     *          operating in playback mode, such as a text chat application, set this
     *          to true so that Amazon Lex V2 doesn't wait for the prompt to finish playing on
     *          the client.</p>
     */ disablePlayback ? : boolean ; /**
     * <p>A unique identifier that your application assigns to the event. You
     *          can use this to identify events in logs.</p>
     */ eventId ? : string ; /**
     * <p>A timestamp set by the client of the date and time that the event
     *          was sent to Amazon Lex V2.</p>
     */ clientTimestampMillis ? : number ; } export namespace ConfigurationEvent { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , ... ( obj . welcomeMessages && { welcomeMessages : obj . welcomeMessages . map ( ( item ) => Message . filterSensitiveLog ( item ) ) , } ) , } ) ; } export interface PutSessionRequest { /**
     * <p>The identifier of the bot that receives the session data.</p>
     */ botId : string | undefined ; /**
     * <p>The alias identifier of the bot that receives the session
     *          data.</p>
     */ botAliasId : string | undefined ; /**
     * <p>The locale where the session is in use.</p>
     */ localeId : string | undefined ; /**
     * <p>The identifier of the session that receives the session data.</p>
     */ sessionId : string | undefined ; /**
     * <p>A list of messages to send to the user. Messages are sent in the
     *          order that they are defined in the list.</p>
     */ messages ? : Message [ ] ; /**
     * <p>Sets the state of the session with the user. You can use this to set
     *          the current intent, attributes, context, and dialog action. Use the
     *          dialog action to determine the next step that Amazon Lex V2 should use in the
     *          conversation with the user.</p>
     */ sessionState : SessionState | undefined ; /**
     * <p>Request-specific information passed between Amazon Lex V2 and the client
     *          application.</p>
     *          <p>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>.</p>
     */ requestAttributes ? : { [ key ] : string ; } ; /**
     * <p>The message that Amazon Lex V2 returns in the response can be either text or
     *          speech depending on the value of this parameter. </p>
     *          <ul>
     *             <li>
     *                <p>If the value is <code>text/plain; charset=utf-8</code>, Amazon Lex V2
     *                returns text in the response.</p>
     *             </li>
     *          </ul>
     */ responseContentType ? : string ; } export namespace PutSessionRequest { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , ... ( obj . messages && { messages : obj . messages . map ( ( item ) => Message . filterSensitiveLog ( item ) ) } ) , } ) ; } export interface RecognizeTextRequest { /**
     * <p>The identifier of the bot that processes the request.</p>
     */ botId : string | undefined ; /**
     * <p>The alias identifier in use for the bot that processes the
     *          request.</p>
     */ botAliasId : string | undefined ; /**
     * <p>The locale where the session is in use.</p>
     */ localeId : string | undefined ; /**
     * <p>The identifier of the user session that is having the
     *          conversation.</p>
     */ sessionId : string | undefined ; /**
     * <p>The text that the user entered. Amazon Lex V2 interprets this text.</p>
     */ text : string | undefined ; /**
     * <p>The current state of the dialog between the user and the bot.</p>
     */ sessionState ? : SessionState ; /**
     * <p>Request-specific information passed between the client application
     *          and Amazon Lex V2 </p>
     *          <p>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>.</p>
     */ requestAttributes ? : { [ key ] : string ; } ; } export namespace RecognizeTextRequest { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , ... ( obj . text && { text : SENSITIVE_STRING } ) , } ) ; } /**
 * <p>Represents a stream of events between your application and
 *          Amazon Lex V2.</p>
 */ export type StartConversationRequestEventStream = StartConversationRequestEventStream . AudioInputEventMember | StartConversationRequestEventStream . ConfigurationEventMember | StartConversationRequestEventStream . DTMFInputEventMember | StartConversationRequestEventStream . DisconnectionEventMember | StartConversationRequestEventStream . PlaybackCompletionEventMember | StartConversationRequestEventStream . TextInputEventMember | StartConversationRequestEventStream . $UnknownMember ; export namespace StartConversationRequestEventStream { /**
     * <p>Configuration information sent from your client application to
     *          Amazon Lex V2</p>
     */ export interface ConfigurationEventMember { ConfigurationEvent : ConfigurationEvent ; AudioInputEvent ? : never ; DTMFInputEvent ? : never ; TextInputEvent ? : never ; PlaybackCompletionEvent ? : never ; DisconnectionEvent ? : never ; $unknown ? : never ; } /**
     * <p>Speech audio sent from your client application to Amazon Lex V2. Audio
     *          starts accumulating when Amazon Lex V2 identifies a voice and continues until a
     *          natural pause in the speech is found before processing.</p>
     */ export interface AudioInputEventMember { ConfigurationEvent ? : never ; AudioInputEvent : AudioInputEvent ; DTMFInputEvent ? : never ; TextInputEvent ? : never ; PlaybackCompletionEvent ? : never ; DisconnectionEvent ? : never ; $unknown ? : never ; } /**
     * <p>DTMF information sent to Amazon Lex V2 by your application. Amazon Lex V2
     *          accumulates the DMTF information from when the user sends the first
     *          character and ends</p>
     *          <ul>
     *             <li>
     *                <p>when there's a pause longer that the value configured for the
     *                end timeout.</p>
     *             </li>
     *             <li>
     *                <p>when there's a digit that is the configured end
     *                character.</p>
     *             </li>
     *             <li>
     *                <p>when Amazon Lex V2 accumulates characters equal to the maximum DTMF
     *                character configuration.</p>
     *             </li>
     *          </ul>
     */ export interface DTMFInputEventMember { ConfigurationEvent ? : never ; AudioInputEvent ? : never ; DTMFInputEvent : DTMFInputEvent ; TextInputEvent ? : never ; PlaybackCompletionEvent ? : never ; DisconnectionEvent ? : never ; $unknown ? : never ; } /**
     * <p>Text sent from your client application to Amazon Lex V2. Each
     *             <code>TextInputEvent</code> is processed individually.</p>
     */ export interface TextInputEventMember { ConfigurationEvent ? : never ; AudioInputEvent ? : never ; DTMFInputEvent ? : never ; TextInputEvent : TextInputEvent ; PlaybackCompletionEvent ? : never ; DisconnectionEvent ? : never ; $unknown ? : never ; } /**
     * <p>Event sent from the client application to Amazon Lex V2 to indicate that it
     *          has finished playing audio and that Amazon Lex V2 should start listening for
     *          user input.</p>
     */ export interface PlaybackCompletionEventMember { ConfigurationEvent ? : never ; AudioInputEvent ? : never ; DTMFInputEvent ? : never ; TextInputEvent ? : never ; PlaybackCompletionEvent : PlaybackCompletionEvent ; DisconnectionEvent ? : never ; $unknown ? : never ; } /**
     * <p>Event sent from the client application to indicate to Amazon Lex V2 that the
     *          conversation is over.</p>
     */ export interface DisconnectionEventMember { ConfigurationEvent ? : never ; AudioInputEvent ? : never ; DTMFInputEvent ? : never ; TextInputEvent ? : never ; PlaybackCompletionEvent ? : never ; DisconnectionEvent : DisconnectionEvent ; $unknown ? : never ; } export interface $UnknownMember { ConfigurationEvent ? : never ; AudioInputEvent ? : never ; DTMFInputEvent ? : never ; TextInputEvent ? : never ; PlaybackCompletionEvent ? : never ; DisconnectionEvent ? : never ; $unknown : [ string , any ] ; } export interface Visitor < T > { ConfigurationEvent : ( value : ConfigurationEvent ) => T ; AudioInputEvent : ( value : AudioInputEvent ) => T ; DTMFInputEvent : ( value : DTMFInputEvent ) => T ; TextInputEvent : ( value : TextInputEvent ) => T ; PlaybackCompletionEvent : ( value : PlaybackCompletionEvent ) => T ; DisconnectionEvent : ( value : DisconnectionEvent ) => T ; _ : ( name : string , value : any ) => T ; } export const visit = < T > ( value , visitor ) : T => { if ( value . ConfigurationEvent !== undefined ) return visitor . ConfigurationEvent ( value . ConfigurationEvent ) ; if ( value . AudioInputEvent !== undefined ) return visitor . AudioInputEvent ( value . AudioInputEvent ) ; if ( value . DTMFInputEvent !== undefined ) return visitor . DTMFInputEvent ( value . DTMFInputEvent ) ; if ( value . TextInputEvent !== undefined ) return visitor . TextInputEvent ( value . TextInputEvent ) ; if ( value . PlaybackCompletionEvent !== undefined ) return visitor . PlaybackCompletionEvent ( value . PlaybackCompletionEvent ) ; if ( value . DisconnectionEvent !== undefined ) return visitor . DisconnectionEvent ( value . DisconnectionEvent ) ; return visitor . _ ( value . $unknown [ 0 ] , value . $unknown [ 1 ] ) ; } ; internal export const filterSensitiveLog = ( obj ) : any => { if ( obj . ConfigurationEvent !== undefined ) return { ConfigurationEvent : ConfigurationEvent . filterSensitiveLog ( obj . ConfigurationEvent ) } ; if ( obj . AudioInputEvent !== undefined ) return { AudioInputEvent : AudioInputEvent . filterSensitiveLog ( obj . AudioInputEvent ) } ; if ( obj . DTMFInputEvent !== undefined ) return { DTMFInputEvent : DTMFInputEvent . filterSensitiveLog ( obj . DTMFInputEvent ) } ; if ( obj . TextInputEvent !== undefined ) return { TextInputEvent : TextInputEvent . filterSensitiveLog ( obj . TextInputEvent ) } ; if ( obj . PlaybackCompletionEvent !== undefined ) return { PlaybackCompletionEvent : PlaybackCompletionEvent . filterSensitiveLog ( obj . PlaybackCompletionEvent ) } ; if ( obj . DisconnectionEvent !== undefined ) return { DisconnectionEvent : DisconnectionEvent . filterSensitiveLog ( obj . DisconnectionEvent ) } ; if ( obj . $unknown !== undefined ) return { [ obj . $unknown [ 0 ] ] : "UNKNOWN" } ; } ; } export interface StartConversationRequest { /**
     * <p>The identifier of the bot to process the request.</p>
     */ botId : string | undefined ; /**
     * <p>The alias identifier in use for the bot that processes the
     *          request.</p>
     */ botAliasId : string | undefined ; /**
     * <p>The locale where the session is in use.</p>
     */ localeId : string | undefined ; /**
     * <p>The identifier of the user session that is having the
     *          conversation.</p>
     */ sessionId : string | undefined ; /**
     * <p>The conversation type that you are using the Amazon Lex V2. If the
     *          conversation mode is <code>AUDIO</code> you can send both audio and
     *          DTMF information. If the mode is <code>TEXT</code> you can only send
     *          text.</p>
     */ conversationMode ? : ConversationMode | string ; /**
     * <p>Represents the stream of events to Amazon Lex V2 from your application. The
     *          events are encoded as HTTP/2 data frames.</p>
     */ requestEventStream : AsyncIterable < StartConversationRequestEventStream > | undefined ; } export namespace StartConversationRequest { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , ... ( obj . requestEventStream && { requestEventStream : "STREAMING_CONTENT" } ) , } ) ; } export interface GetSessionResponse { /**
     * <p>The identifier of the returned session.</p>
     */ sessionId ? : string ; /**
     * <p>A list of messages that were last sent to the user. The messages are
     *          ordered based on the order that your returned the messages from your
     *          Lambda function or the order that messages are defined in the bot.
     *       </p>
     */ messages ? : Message [ ] ; /**
     * <p>A list of intents that Amazon Lex V2 determined might satisfy the user's
     *          utterance. </p>
     *          <p>Each interpretation includes the intent, a score that indicates how
     *          confident Amazon Lex V2 is that the interpretation is the correct one, and an
     *          optional sentiment response that indicates the sentiment expressed in
     *          the utterance.</p>
     */ interpretations ? : Interpretation [ ] ; /**
     * <p>Represents the current state of the dialog between the user and the
     *          bot.</p>
     *          <p>You can use this to determine the progress of the conversation and
     *          what the next action might be.</p>
     */ sessionState ? : SessionState ; } export namespace GetSessionResponse { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , ... ( obj . messages && { messages : obj . messages . map ( ( item ) => Message . filterSensitiveLog ( item ) ) } ) , } ) ; } /**
 * <p>Contains the current state of the conversation between the client
 *          application and Amazon Lex V2.</p>
 */ export interface IntentResultEvent { /**
     * <p>Indicates whether the input to the operation was text or
     *          speech.</p>
     */ inputMode ? : InputMode | string ; /**
     * <p>A list of intents that Amazon Lex V2 determined might satisfy the user's
     *          utterance.</p>
     *
     *          <p>Each interpretation includes the intent, a score that indicates how
     *          confident Amazon Lex V2 is that the interpretation is the correct one, and an
     *          optional sentiment response that indicates the sentiment expressed in
     *          the utterance.</p>
     */ interpretations ? : Interpretation [ ] ; /**
     * <p>The state of the user's session with Amazon Lex V2.</p>
     */ sessionState ? : SessionState ; /**
     * <p>The attributes sent in the request.</p>
     */ requestAttributes ? : { [ key ] : string ; } ; /**
     * <p>The identifier of the session in use.</p>
     */ sessionId ? : string ; /**
     * <p>A unique identifier of the event sent by Amazon Lex V2. The identifier is in
     *          the form <code>RESPONSE-N</code>, where N is a number starting with one
     *          and incremented for each event sent by Amazon Lex V2 in the current
     *          session.</p>
     */ eventId ? : string ; } export namespace IntentResultEvent { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , } ) ; } export interface RecognizeTextResponse { /**
     * <p>A list of messages last sent to the user. The messages are ordered
     *          based on the order that you returned the messages from your Lambda
     *          function or the order that the messages are defined in the bot.</p>
     */ messages ? : Message [ ] ; /**
     * <p>Represents the current state of the dialog between the user and the
     *          bot. </p>
     *          <p>Use this to determine the progress of the conversation and what the
     *          next action may be.</p>
     */ sessionState ? : SessionState ; /**
     * <p>A list of intents that Amazon Lex V2 determined might satisfy the user's
     *          utterance. </p>
     *          <p>Each interpretation includes the intent, a score that indicates now
     *          confident Amazon Lex V2 is that the interpretation is the correct one, and an
     *          optional sentiment response that indicates the sentiment expressed in
     *          the utterance.</p>
     */ interpretations ? : Interpretation [ ] ; /**
     * <p>The attributes sent in the request.</p>
     */ requestAttributes ? : { [ key ] : string ; } ; /**
     * <p>The identifier of the session in use.</p>
     */ sessionId ? : string ; } export namespace RecognizeTextResponse { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , ... ( obj . messages && { messages : obj . messages . map ( ( item ) => Message . filterSensitiveLog ( item ) ) } ) , } ) ; } /**
 * <p>Represents a stream of events between Amazon Lex V2 and your
 *          application.</p>
 */ export type StartConversationResponseEventStream = StartConversationResponseEventStream . AccessDeniedExceptionMember | StartConversationResponseEventStream . AudioResponseEventMember | StartConversationResponseEventStream . BadGatewayExceptionMember | StartConversationResponseEventStream . ConflictExceptionMember | StartConversationResponseEventStream . DependencyFailedExceptionMember | StartConversationResponseEventStream . HeartbeatEventMember | StartConversationResponseEventStream . IntentResultEventMember | StartConversationResponseEventStream . InternalServerExceptionMember | StartConversationResponseEventStream . PlaybackInterruptionEventMember | StartConversationResponseEventStream . ResourceNotFoundExceptionMember | StartConversationResponseEventStream . TextResponseEventMember | StartConversationResponseEventStream . ThrottlingExceptionMember | StartConversationResponseEventStream . TranscriptEventMember | StartConversationResponseEventStream . ValidationExceptionMember | StartConversationResponseEventStream . $UnknownMember ; export namespace StartConversationResponseEventStream { /**
     * <p>Event sent from Amazon Lex V2 to indicate to the client application should
     *          stop playback of audio. For example, if the client is playing a prompt
     *          that asks for the user's telephone number, the user might start to say
     *          the phone number before the prompt is complete. Amazon Lex V2 sends this event
     *          to the client application to indicate that the user is responding and
     *          that Amazon Lex V2 is processing their input.</p>
     */ export interface PlaybackInterruptionEventMember { PlaybackInterruptionEvent : PlaybackInterruptionEvent ; TranscriptEvent ? : never ; IntentResultEvent ? : never ; TextResponseEvent ? : never ; AudioResponseEvent ? : never ; HeartbeatEvent ? : never ; AccessDeniedException ? : never ; ResourceNotFoundException ? : never ; ValidationException ? : never ; ThrottlingException ? : never ; InternalServerException ? : never ; ConflictException ? : never ; DependencyFailedException ? : never ; BadGatewayException ? : never ; $unknown ? : never ; } /**
     * <p>Event sent from Amazon Lex V2 to your client application that contains a
     *          transcript of voice audio. </p>
     */ export interface TranscriptEventMember { PlaybackInterruptionEvent ? : never ; TranscriptEvent : TranscriptEvent ; IntentResultEvent ? : never ; TextResponseEvent ? : never ; AudioResponseEvent ? : never ; HeartbeatEvent ? : never ; AccessDeniedException ? : never ; ResourceNotFoundException ? : never ; ValidationException ? : never ; ThrottlingException ? : never ; InternalServerException ? : never ; ConflictException ? : never ; DependencyFailedException ? : never ; BadGatewayException ? : never ; $unknown ? : never ; } /**
     * <p>Event sent from Amazon Lex V2 to the client application containing the
     *          current state of the conversation between the user and Amazon Lex V2.</p>
     */ export interface IntentResultEventMember { PlaybackInterruptionEvent ? : never ; TranscriptEvent ? : never ; IntentResultEvent : IntentResultEvent ; TextResponseEvent ? : never ; AudioResponseEvent ? : never ; HeartbeatEvent ? : never ; AccessDeniedException ? : never ; ResourceNotFoundException ? : never ; ValidationException ? : never ; ThrottlingException ? : never ; InternalServerException ? : never ; ConflictException ? : never ; DependencyFailedException ? : never ; BadGatewayException ? : never ; $unknown ? : never ; } /**
     * <p>The event sent from Amazon Lex V2 to your application with text to present
     *          to the user.</p>
     */ export interface TextResponseEventMember { PlaybackInterruptionEvent ? : never ; TranscriptEvent ? : never ; IntentResultEvent ? : never ; TextResponseEvent : TextResponseEvent ; AudioResponseEvent ? : never ; HeartbeatEvent ? : never ; AccessDeniedException ? : never ; ResourceNotFoundException ? : never ; ValidationException ? : never ; ThrottlingException ? : never ; InternalServerException ? : never ; ConflictException ? : never ; DependencyFailedException ? : never ; BadGatewayException ? : never ; $unknown ? : never ; } /**
     * <p>An event sent from Amazon Lex V2 to your client application containing audio
     *          to play to the user. </p>
     */ export interface AudioResponseEventMember { PlaybackInterruptionEvent ? : never ; TranscriptEvent ? : never ; IntentResultEvent ? : never ; TextResponseEvent ? : never ; AudioResponseEvent : AudioResponseEvent ; HeartbeatEvent ? : never ; AccessDeniedException ? : never ; ResourceNotFoundException ? : never ; ValidationException ? : never ; ThrottlingException ? : never ; InternalServerException ? : never ; ConflictException ? : never ; DependencyFailedException ? : never ; BadGatewayException ? : never ; $unknown ? : never ; } /**
     * <p>Event that Amazon Lex V2 sends to indicate that the stream is still open
     *          between the client application and Amazon Lex V2 </p>
     */ export interface HeartbeatEventMember { PlaybackInterruptionEvent ? : never ; TranscriptEvent ? : never ; IntentResultEvent ? : never ; TextResponseEvent ? : never ; AudioResponseEvent ? : never ; HeartbeatEvent : HeartbeatEvent ; AccessDeniedException ? : never ; ResourceNotFoundException ? : never ; ValidationException ? : never ; ThrottlingException ? : never ; InternalServerException ? : never ; ConflictException ? : never ; DependencyFailedException ? : never ; BadGatewayException ? : never ; $unknown ? : never ; } /**
     * <p>Exception thrown when the credentials passed with the request are
     *          invalid or expired. Also thrown when the credentials in the request do
     *          not have permission to access the <code>StartConversation</code>
     *          operation.</p>
     */ export interface AccessDeniedExceptionMember { PlaybackInterruptionEvent ? : never ; TranscriptEvent ? : never ; IntentResultEvent ? : never ; TextResponseEvent ? : never ; AudioResponseEvent ? : never ; HeartbeatEvent ? : never ; AccessDeniedException : AccessDeniedException ; ResourceNotFoundException ? : never ; ValidationException ? : never ; ThrottlingException ? : never ; InternalServerException ? : never ; ConflictException ? : never ; DependencyFailedException ? : never ; BadGatewayException ? : never ; $unknown ? : never ; } /**
     * <p>Exception thrown if one of the input parameters points to a resource
     *          that does not exist. For example, if the bot ID specified does not
     *          exist.</p>
     */ export interface ResourceNotFoundExceptionMember { PlaybackInterruptionEvent ? : never ; TranscriptEvent ? : never ; IntentResultEvent ? : never ; TextResponseEvent ? : never ; AudioResponseEvent ? : never ; HeartbeatEvent ? : never ; AccessDeniedException ? : never ; ResourceNotFoundException : ResourceNotFoundException ; ValidationException ? : never ; ThrottlingException ? : never ; InternalServerException ? : never ; ConflictException ? : never ; DependencyFailedException ? : never ; BadGatewayException ? : never ; $unknown ? : never ; } /**
     * <p>Exception thrown when one or more parameters could not be validated.
     *          The <code>message</code> contains the name of the field that isn't
     *          valid.</p>
     */ export interface ValidationExceptionMember { PlaybackInterruptionEvent ? : never ; TranscriptEvent ? : never ; IntentResultEvent ? : never ; TextResponseEvent ? : never ; AudioResponseEvent ? : never ; HeartbeatEvent ? : never ; AccessDeniedException ? : never ; ResourceNotFoundException ? : never ; ValidationException : ValidationException ; ThrottlingException ? : never ; InternalServerException ? : never ; ConflictException ? : never ; DependencyFailedException ? : never ; BadGatewayException ? : never ; $unknown ? : never ; } /**
     * <p>Exception thrown when your application exceeds the maximum number of
     *          concurrent requests. </p>
     */ export interface ThrottlingExceptionMember { PlaybackInterruptionEvent ? : never ; TranscriptEvent ? : never ; IntentResultEvent ? : never ; TextResponseEvent ? : never ; AudioResponseEvent ? : never ; HeartbeatEvent ? : never ; AccessDeniedException ? : never ; ResourceNotFoundException ? : never ; ValidationException ? : never ; ThrottlingException : ThrottlingException ; InternalServerException ? : never ; ConflictException ? : never ; DependencyFailedException ? : never ; BadGatewayException ? : never ; $unknown ? : never ; } /**
     * <p>An error occurred with Amazon Lex V2.</p>
     */ export interface InternalServerExceptionMember { PlaybackInterruptionEvent ? : never ; TranscriptEvent ? : never ; IntentResultEvent ? : never ; TextResponseEvent ? : never ; AudioResponseEvent ? : never ; HeartbeatEvent ? : never ; AccessDeniedException ? : never ; ResourceNotFoundException ? : never ; ValidationException ? : never ; ThrottlingException ? : never ; InternalServerException : InternalServerException ; ConflictException ? : never ; DependencyFailedException ? : never ; BadGatewayException ? : never ; $unknown ? : never ; } /**
     * <p>Exception thrown when two clients are using the same AWS account,
     *          Amazon Lex V2 bot, and session ID.</p>
     */ export interface ConflictExceptionMember { PlaybackInterruptionEvent ? : never ; TranscriptEvent ? : never ; IntentResultEvent ? : never ; TextResponseEvent ? : never ; AudioResponseEvent ? : never ; HeartbeatEvent ? : never ; AccessDeniedException ? : never ; ResourceNotFoundException ? : never ; ValidationException ? : never ; ThrottlingException ? : never ; InternalServerException ? : never ; ConflictException : ConflictException ; DependencyFailedException ? : never ; BadGatewayException ? : never ; $unknown ? : never ; } /**
     * <p></p>
     */ export interface DependencyFailedExceptionMember { PlaybackInterruptionEvent ? : never ; TranscriptEvent ? : never ; IntentResultEvent ? : never ; TextResponseEvent ? : never ; AudioResponseEvent ? : never ; HeartbeatEvent ? : never ; AccessDeniedException ? : never ; ResourceNotFoundException ? : never ; ValidationException ? : never ; ThrottlingException ? : never ; InternalServerException ? : never ; ConflictException ? : never ; DependencyFailedException : DependencyFailedException ; BadGatewayException ? : never ; $unknown ? : never ; } /**
     * <p></p>
     */ export interface BadGatewayExceptionMember { PlaybackInterruptionEvent ? : never ; TranscriptEvent ? : never ; IntentResultEvent ? : never ; TextResponseEvent ? : never ; AudioResponseEvent ? : never ; HeartbeatEvent ? : never ; AccessDeniedException ? : never ; ResourceNotFoundException ? : never ; ValidationException ? : never ; ThrottlingException ? : never ; InternalServerException ? : never ; ConflictException ? : never ; DependencyFailedException ? : never ; BadGatewayException : BadGatewayException ; $unknown ? : never ; } export interface $UnknownMember { PlaybackInterruptionEvent ? : never ; TranscriptEvent ? : never ; IntentResultEvent ? : never ; TextResponseEvent ? : never ; AudioResponseEvent ? : never ; HeartbeatEvent ? : never ; AccessDeniedException ? : never ; ResourceNotFoundException ? : never ; ValidationException ? : never ; ThrottlingException ? : never ; InternalServerException ? : never ; ConflictException ? : never ; DependencyFailedException ? : never ; BadGatewayException ? : never ; $unknown : [ string , any ] ; } export interface Visitor < T > { PlaybackInterruptionEvent : ( value : PlaybackInterruptionEvent ) => T ; TranscriptEvent : ( value : TranscriptEvent ) => T ; IntentResultEvent : ( value : IntentResultEvent ) => T ; TextResponseEvent : ( value : TextResponseEvent ) => T ; AudioResponseEvent : ( value : AudioResponseEvent ) => T ; HeartbeatEvent : ( value : HeartbeatEvent ) => T ; AccessDeniedException : ( value : AccessDeniedException ) => T ; ResourceNotFoundException : ( value : ResourceNotFoundException ) => T ; ValidationException : ( value : ValidationException ) => T ; ThrottlingException : ( value : ThrottlingException ) => T ; InternalServerException : ( value : InternalServerException ) => T ; ConflictException : ( value : ConflictException ) => T ; DependencyFailedException : ( value : DependencyFailedException ) => T ; BadGatewayException : ( value : BadGatewayException ) => T ; _ : ( name : string , value : any ) => T ; } export const visit = < T > ( value , visitor ) : T => { if ( value . PlaybackInterruptionEvent !== undefined ) return visitor . PlaybackInterruptionEvent ( value . PlaybackInterruptionEvent ) ; if ( value . TranscriptEvent !== undefined ) return visitor . TranscriptEvent ( value . TranscriptEvent ) ; if ( value . IntentResultEvent !== undefined ) return visitor . IntentResultEvent ( value . IntentResultEvent ) ; if ( value . TextResponseEvent !== undefined ) return visitor . TextResponseEvent ( value . TextResponseEvent ) ; if ( value . AudioResponseEvent !== undefined ) return visitor . AudioResponseEvent ( value . AudioResponseEvent ) ; if ( value . HeartbeatEvent !== undefined ) return visitor . HeartbeatEvent ( value . HeartbeatEvent ) ; if ( value . AccessDeniedException !== undefined ) return visitor . AccessDeniedException ( value . AccessDeniedException ) ; if ( value . ResourceNotFoundException !== undefined ) return visitor . ResourceNotFoundException ( value . ResourceNotFoundException ) ; if ( value . ValidationException !== undefined ) return visitor . ValidationException ( value . ValidationException ) ; if ( value . ThrottlingException !== undefined ) return visitor . ThrottlingException ( value . ThrottlingException ) ; if ( value . InternalServerException !== undefined ) return visitor . InternalServerException ( value . InternalServerException ) ; if ( value . ConflictException !== undefined ) return visitor . ConflictException ( value . ConflictException ) ; if ( value . DependencyFailedException !== undefined ) return visitor . DependencyFailedException ( value . DependencyFailedException ) ; if ( value . BadGatewayException !== undefined ) return visitor . BadGatewayException ( value . BadGatewayException ) ; return visitor . _ ( value . $unknown [ 0 ] , value . $unknown [ 1 ] ) ; } ; internal export const filterSensitiveLog = ( obj ) : any => { if ( obj . PlaybackInterruptionEvent !== undefined ) return { PlaybackInterruptionEvent : PlaybackInterruptionEvent . filterSensitiveLog ( obj . PlaybackInterruptionEvent ) } ; if ( obj . TranscriptEvent !== undefined ) return { TranscriptEvent : TranscriptEvent . filterSensitiveLog ( obj . TranscriptEvent ) } ; if ( obj . IntentResultEvent !== undefined ) return { IntentResultEvent : IntentResultEvent . filterSensitiveLog ( obj . IntentResultEvent ) } ; if ( obj . TextResponseEvent !== undefined ) return { TextResponseEvent : TextResponseEvent . filterSensitiveLog ( obj . TextResponseEvent ) } ; if ( obj . AudioResponseEvent !== undefined ) return { AudioResponseEvent : AudioResponseEvent . filterSensitiveLog ( obj . AudioResponseEvent ) } ; if ( obj . HeartbeatEvent !== undefined ) return { HeartbeatEvent : HeartbeatEvent . filterSensitiveLog ( obj . HeartbeatEvent ) } ; if ( obj . AccessDeniedException !== undefined ) return { AccessDeniedException : obj . AccessDeniedException } ; if ( obj . ResourceNotFoundException !== undefined ) return { ResourceNotFoundException : obj . ResourceNotFoundException } ; if ( obj . ValidationException !== undefined ) return { ValidationException : obj . ValidationException } ; if ( obj . ThrottlingException !== undefined ) return { ThrottlingException : obj . ThrottlingException } ; if ( obj . InternalServerException !== undefined ) return { InternalServerException : obj . InternalServerException } ; if ( obj . ConflictException !== undefined ) return { ConflictException : obj . ConflictException } ; if ( obj . DependencyFailedException !== undefined ) return { DependencyFailedException : obj . DependencyFailedException } ; if ( obj . BadGatewayException !== undefined ) return { BadGatewayException : obj . BadGatewayException } ; if ( obj . $unknown !== undefined ) return { [ obj . $unknown [ 0 ] ] : "UNKNOWN" } ; } ; } export interface StartConversationResponse { /**
     * <p>Represents the stream of events from Amazon Lex V2 to your application. The
     *          events are encoded as HTTP/2 data frames.</p>
     */ responseEventStream ? : AsyncIterable < StartConversationResponseEventStream > ; } export namespace StartConversationResponse { internal export const filterSensitiveLog = ( obj ) : any => ( { ... obj , ... ( obj . responseEventStream && { responseEventStream : "STREAMING_CONTENT" } ) , } ) ; }