@propulsionworks/cloudformation 0.0.2 → 0.1.0

package/out/exports/resources.generated/aws-lex-bot.d.ts

@@ -0,0 +1,1730 @@
+import type { ResourceDefinitionWithAttributes, Tag } from "../main.ts";
+export type LexBot = ResourceDefinitionWithAttributes<"AWS::Lex::Bot", LexBotProps, LexBotAttribs>;
+/**
+ * > Amazon Lex V2 is the only supported version in AWS CloudFormation .
+ *
+ * Specifies an Amazon Lex conversational bot.
+ *
+ * You must configure an intent based on the `AMAZON.FallbackIntent` built-in intent. If you don't add one, creating the bot will fail.
+ */
+export type LexBotProps = {
+    /**
+     * Indicates whether Amazon Lex V2 should automatically build the locales for the bot after a change.
+     */
+    AutoBuildBotLocales?: boolean | undefined;
+    /**
+     * The Amazon S3 location of files used to import a bot. The files must be in the import format specified in [JSON format for importing and exporting](https://docs.aws.amazon.com/lexv2/latest/dg/import-export-format.html) in the *Amazon Lex developer guide.*
+     */
+    BotFileS3Location?: S3Location | undefined;
+    /**
+     * A list of locales for the bot.
+     */
+    BotLocales?: BotLocale[] | undefined;
+    /**
+     * A list of tags to add to the bot. You can only add tags when you import a bot. You can't use the `UpdateBot` operation to update tags. To update tags, use the `TagResource` operation.
+     */
+    BotTags?: Tag[] | undefined;
+    /**
+     * By default, data stored by Amazon Lex is encrypted. The `DataPrivacy` structure provides settings that determine how Amazon Lex handles special cases of securing the data for your bot.
+     */
+    DataPrivacy: {
+        ChildDirected: boolean;
+    };
+    /**
+     * The description of the version.
+     */
+    Description?: string | undefined;
+    /**
+     * The time, in seconds, that Amazon Lex should keep information about a user's conversation with the bot.
+     *
+     * A user interaction remains active for the amount of time specified. If no conversation occurs during this time, the session expires and Amazon Lex deletes any data provided before the timeout.
+     *
+     * You can specify between 60 (1 minute) and 86,400 (24 hours) seconds.
+     * @min 60
+     * @max 86400
+     */
+    IdleSessionTTLInSeconds: number;
+    /**
+     * The name of the bot locale.
+     */
+    Name: string;
+    Replication?: Replication | undefined;
+    /**
+     * The Amazon Resource Name (ARN) of the IAM role used to build and run the bot.
+     */
+    RoleArn: string;
+    /**
+     * Specifies configuration settings for the alias used to test the bot. If the `TestBotAliasSettings` property is not specified, the settings are configured with default values.
+     */
+    TestBotAliasSettings?: TestBotAliasSettings | undefined;
+    /**
+     * A list of tags to add to the test alias for a bot. You can only add tags when you import a bot. You can't use the `UpdateAlias` operation to update tags. To update tags on the test alias, use the `TagResource` operation.
+     */
+    TestBotAliasTags?: Tag[] | undefined;
+};
+export type LexBotAttribs = {
+    /**
+     * The Amazon Resource Name (ARN) of the bot.
+     */
+    Arn: string;
+    /**
+     * The unique identifier of the bot.
+     */
+    Id: string;
+};
+/**
+ * Provides settings that enable advanced recognition settings for slot values.
+ */
+export type AdvancedRecognitionSetting = {
+    /**
+     * Enables using the slot values as a custom vocabulary for recognizing user utterances.
+     */
+    AudioRecognitionStrategy?: AudioRecognitionStrategy | undefined;
+};
+/**
+ * Specifies the allowed input types.
+ */
+export type AllowedInputTypes = {
+    /**
+     * Indicates whether audio input is allowed.
+     */
+    AllowAudioInput: boolean;
+    /**
+     * Indicates whether DTMF input is allowed.
+     */
+    AllowDTMFInput: boolean;
+};
+/**
+ * Specifies the audio and DTMF input specification.
+ */
+export type AudioAndDTMFInputSpecification = {
+    /**
+     * Specifies the settings on audio input.
+     */
+    AudioSpecification?: AudioSpecification | undefined;
+    /**
+     * Specifies the settings on DTMF input.
+     */
+    DTMFSpecification?: DTMFSpecification | undefined;
+    /**
+     * Time for which a bot waits before assuming that the customer isn't going to speak or press a key. This timeout is shared between Audio and DTMF inputs.
+     * @min 1
+     */
+    StartTimeoutMs: number;
+};
+/**
+ * The location of audio log files collected when conversation logging is enabled for a bot.
+ */
+export type AudioLogDestination = {
+    /**
+     * Specifies the Amazon S3 bucket where the audio files are stored.
+     */
+    S3Bucket: S3BucketLogDestination;
+};
+/**
+ * Settings for logging audio of conversations between Amazon Lex and a user. You specify whether to log audio and the Amazon S3 bucket where the audio file is stored.
+ */
+export type AudioLogSetting = {
+    /**
+     * Specifies the location of the audio log files collected when conversation logging is enabled for a bot.
+     */
+    Destination: AudioLogDestination;
+    /**
+     * Determines whether audio logging in enabled for the bot.
+     */
+    Enabled: boolean;
+};
+export type AudioRecognitionStrategy = "UseSlotValuesAsCustomVocabulary";
+/**
+ * Specifies the audio input specifications.
+ */
+export type AudioSpecification = {
+    /**
+     * Time for which a bot waits after the customer stops speaking to assume the utterance is finished.
+     * @min 1
+     */
+    EndTimeoutMs: number;
+    /**
+     * Time for how long Amazon Lex waits before speech input is truncated and the speech is returned to application.
+     * @min 1
+     */
+    MaxLengthMs: number;
+};
+export type BedrockAgentIntentConfiguration = {
+    BedrockAgentConfiguration?: {
+        /**
+         * @minLength 1
+         * @maxLength 5000
+         */
+        BedrockAgentAliasId?: string | undefined;
+        /**
+         * @minLength 1
+         * @maxLength 5000
+         */
+        BedrockAgentId?: string | undefined;
+    } | undefined;
+    BedrockAgentIntentKnowledgeBaseConfiguration?: {
+        /**
+         * @minLength 1
+         * @maxLength 5000
+         */
+        BedrockKnowledgeBaseArn: string;
+        BedrockModelConfiguration: BedrockModelSpecification;
+    } | undefined;
+};
+/**
+ * Contains information about the Amazon Bedrock model used to interpret the prompt used in descriptive bot building.
+ */
+export type BedrockModelSpecification = {
+    BedrockGuardrailConfiguration?: {
+        /**
+         * @minLength 1
+         * @maxLength 5000
+         */
+        BedrockGuardrailIdentifier?: string | undefined;
+        /**
+         * @minLength 1
+         * @maxLength 5000
+         */
+        BedrockGuardrailVersion?: string | undefined;
+    } | undefined;
+    /**
+     * @minLength 1
+     * @maxLength 5000
+     */
+    BedrockModelCustomPrompt?: string | undefined;
+    BedrockTraceStatus?: "ENABLED" | "DISABLED" | undefined;
+    /**
+     * The ARN of the foundation model used in descriptive bot building.
+     * @minLength 1
+     * @maxLength 5000
+     */
+    ModelArn: string;
+};
+/**
+ * Specifies settings that are unique to a locale. For example, you can use different Lambda function depending on the bot's locale.
+ */
+export type BotAliasLocaleSettings = {
+    /**
+     * Specifies the Lambda function that should be used in the locale.
+     */
+    CodeHookSpecification?: CodeHookSpecification | undefined;
+    /**
+     * Determines whether the locale is enabled for the bot. If the value is `false` , the locale isn't available for use.
+     */
+    Enabled: boolean;
+};
+/**
+ * Specifies locale settings for a single locale.
+ */
+export type BotAliasLocaleSettingsItem = {
+    /**
+     * Specifies locale settings for a locale.
+     */
+    BotAliasLocaleSetting: BotAliasLocaleSettings;
+    /**
+     * Specifies the locale that the settings apply to.
+     * @minLength 1
+     * @maxLength 128
+     */
+    LocaleId: string;
+};
+/**
+ * Provides configuration information for a locale.
+ */
+export type BotLocale = {
+    /**
+     * Specifies a custom vocabulary to use with a specific locale.
+     */
+    CustomVocabulary?: CustomVocabulary | undefined;
+    /**
+     * A description of the bot locale. Use this to help identify the bot locale in lists.
+     */
+    Description?: string | undefined;
+    /**
+     * One or more intents defined for the locale.
+     */
+    Intents?: Intent[] | undefined;
+    /**
+     * The identifier of the language and locale that the bot will be used in. The string must match one of the supported locales.
+     */
+    LocaleId: string;
+    /**
+     * Determines the threshold where Amazon Lex will insert the `AMAZON.FallbackIntent` , `AMAZON.KendraSearchIntent` , or both when returning alternative intents. You must configure an `AMAZON.FallbackIntent` . `AMAZON.KendraSearchIntent` is only inserted if it is configured for the bot.
+     */
+    NluConfidenceThreshold: number;
+    /**
+     * One or more slot types defined for the locale.
+     */
+    SlotTypes?: SlotType[] | undefined;
+    /**
+     * Defines settings for using an Amazon Polly voice to communicate with a user.
+     *
+     * Valid values include:
+     *
+     * - `standard`
+     * - `neural`
+     * - `long-form`
+     * - `generative`
+     */
+    VoiceSettings?: VoiceSettings | undefined;
+};
+/**
+ * Describes a button to use on a response card used to gather slot values from a user.
+ */
+export type Button = {
+    /**
+     * The text that appears on the button. Use this to tell the user what value is returned when they choose this button.
+     * @minLength 1
+     * @maxLength 50
+     */
+    Text: string;
+    /**
+     * The value returned to Amazon Lex when the user chooses this button. This must be one of the slot values configured for the slot.
+     * @minLength 1
+     * @maxLength 50
+     */
+    Value: string;
+};
+/**
+ * The Amazon CloudWatch Logs log group where the text and metadata logs are delivered. The log group must exist before you enable logging.
+ */
+export type CloudWatchLogGroupLogDestination = {
+    /**
+     * The Amazon Resource Name (ARN) of the log group where text and metadata logs are delivered.
+     * @minLength 1
+     * @maxLength 2048
+     */
+    CloudWatchLogGroupArn: string;
+    /**
+     * The prefix of the log stream name within the log group that you specified
+     * @minLength 0
+     * @maxLength 1024
+     */
+    LogPrefix: string;
+};
+/**
+ * Contains information about code hooks that Amazon Lex calls during a conversation.
+ */
+export type CodeHookSpecification = {
+    /**
+     * Specifies a Lambda function that verifies requests to a bot or fulfills the user's request to a bot.
+     */
+    LambdaCodeHook: LambdaCodeHook;
+};
+/**
+ * A composite slot is a combination of two or more slots that capture multiple pieces of information in a single user input.
+ */
+export type CompositeSlotTypeSetting = {
+    /**
+     * Subslots in the composite slot.
+     */
+    SubSlots?: SubSlotTypeComposition[] | undefined;
+};
+/**
+ * Provides an expression that evaluates to true or false.
+ */
+export type Condition = {
+    /**
+     * The expression string that is evaluated.
+     */
+    ExpressionString: string;
+};
+/**
+ * A set of actions that Amazon Lex should run if the condition is matched.
+ */
+export type ConditionalBranch = {
+    /**
+     * Contains the expression to evaluate. If the condition is true, the branch's actions are taken.
+     */
+    Condition: Condition;
+    /**
+     * The name of the branch.
+     */
+    Name: string;
+    /**
+     * The next step in the conversation.
+     */
+    NextStep: DialogState;
+    /**
+     * Specifies a list of message groups that Amazon Lex uses to respond the user input.
+     */
+    Response?: ResponseSpecification | undefined;
+};
+/**
+ * Provides a list of conditional branches. Branches are evaluated in the order that they are entered in the list. The first branch with a condition that evaluates to true is executed. The last branch in the list is the default branch. The default branch should not have any condition expression. The default branch is executed if no other branch has a matching condition.
+ */
+export type ConditionalSpecification = {
+    /**
+     * A list of conditional branches. A conditional branch is made up of a condition, a response and a next step. The response and next step are executed when the condition is true.
+     */
+    ConditionalBranches: ConditionalBranch[];
+    /**
+     * The conditional branch that should be followed when the conditions for other branches are not satisfied. A conditional branch is made up of a condition, a response and a next step.
+     */
+    DefaultBranch: DefaultConditionalBranch;
+    /**
+     * Determines whether a conditional branch is active. When `IsActive` is false, the conditions are not evaluated.
+     */
+    IsActive: boolean;
+};
+/**
+ * Configures conversation logging that saves audio, text, and metadata for the conversations with your users.
+ */
+export type ConversationLogSettings = {
+    /**
+     * The Amazon S3 settings for logging audio to an S3 bucket.
+     */
+    AudioLogSettings?: AudioLogSetting[] | undefined;
+    /**
+     * The Amazon CloudWatch Logs settings for logging text and metadata.
+     */
+    TextLogSettings?: TextLogSetting[] | undefined;
+};
+/**
+ * A custom response string that Amazon Lex sends to your application. You define the content and structure the string.
+ */
+export type CustomPayload = {
+    /**
+     * The string that is sent to your application.
+     * @minLength 1
+     * @maxLength 1000
+     */
+    Value: string;
+};
+/**
+ * Specifies a custom vocabulary. A custom vocabulary is a list of words that you expect to be used during a conversation with your bot.
+ */
+export type CustomVocabulary = {
+    /**
+     * Specifies a list of words that you expect to be used during a conversation with your bot.
+     */
+    CustomVocabularyItems: CustomVocabularyItem[];
+};
+/**
+ * Specifies an entry in a custom vocabulary.
+ */
+export type CustomVocabularyItem = {
+    /**
+     * The DisplayAs value for the custom vocabulary item from the custom vocabulary list.
+     * @minLength 1
+     * @maxLength 100
+     */
+    DisplayAs?: string | undefined;
+    /**
+     * Specifies 1 - 4 words that should be recognized.
+     * @minLength 1
+     * @maxLength 100
+     */
+    Phrase: string;
+    /**
+     * Specifies the degree to which the phrase recognition is boosted. The default value is 1.
+     * @min 0
+     * @max 3
+     */
+    Weight?: number | undefined;
+};
+/**
+ * Specifies the DTMF input specifications.
+ */
+export type DTMFSpecification = {
+    /**
+     * The DTMF character that clears the accumulated DTMF digits and immediately ends the input.
+     * @pattern ^[A-D0-9#*]{1}$
+     */
+    DeletionCharacter: string;
+    /**
+     * The DTMF character that immediately ends input. If the user does not press this character, the input ends after the end timeout.
+     * @pattern ^[A-D0-9#*]{1}$
+     */
+    EndCharacter: string;
+    /**
+     * How long the bot should wait after the last DTMF character input before assuming that the input has concluded.
+     * @min 1
+     */
+    EndTimeoutMs: number;
+    /**
+     * The maximum number of DTMF digits allowed in an utterance.
+     * @min 1
+     * @max 1024
+     */
+    MaxLength: number;
+};
+/**
+ * A set of actions that Amazon Lex should run if none of the other conditions are met.
+ */
+export type DefaultConditionalBranch = {
+    /**
+     * The next step in the conversation.
+     */
+    NextStep?: DialogState | undefined;
+    /**
+     * Specifies a list of message groups that Amazon Lex uses to respond the user input.
+     */
+    Response?: ResponseSpecification | undefined;
+};
+/**
+ * Defines the action that the bot executes at runtime when the conversation reaches this step.
+ */
+export type DialogAction = {
+    /**
+     * If the dialog action is `ElicitSlot` , defines the slot to elicit from the user.
+     */
+    SlotToElicit?: string | undefined;
+    /**
+     * When true the next message for the intent is not used.
+     */
+    SuppressNextMessage?: boolean | undefined;
+    /**
+     * The action that the bot should execute.
+     */
+    Type: DialogActionType;
+};
+export type DialogActionType = "CloseIntent" | "ConfirmIntent" | "ElicitIntent" | "ElicitSlot" | "StartIntent" | "FulfillIntent" | "EndConversation" | "EvaluateConditional" | "InvokeDialogCodeHook";
+/**
+ * Settings that specify the dialog code hook that is called by Amazon Lex at a step of the conversation.
+ */
+export type DialogCodeHookInvocationSetting = {
+    /**
+     * Indicates whether a Lambda function should be invoked for the dialog.
+     */
+    EnableCodeHookInvocation: boolean;
+    /**
+     * A label that indicates the dialog step from which the dialog code hook is happening.
+     */
+    InvocationLabel?: string | undefined;
+    /**
+     * Determines whether a dialog code hook is used when the intent is activated.
+     */
+    IsActive: boolean;
+    /**
+     * Contains the responses and actions that Amazon Lex takes after the Lambda function is complete.
+     */
+    PostCodeHookSpecification: PostDialogCodeHookInvocationSpecification;
+};
+/**
+ * Settings that determine the Lambda function that Amazon Lex uses for processing user responses.
+ */
+export type DialogCodeHookSetting = {
+    /**
+     * Enables the dialog code hook so that it processes user requests.
+     */
+    Enabled: boolean;
+};
+/**
+ * The current state of the conversation with the user.
+ */
+export type DialogState = {
+    /**
+     * Defines the action that the bot executes at runtime when the conversation reaches this step.
+     */
+    DialogAction?: DialogAction | undefined;
+    /**
+     * Override settings to configure the intent state.
+     */
+    Intent?: IntentOverride | undefined;
+    /**
+     * Map of key/value pairs representing session-specific context information. It contains application information passed between Amazon Lex and a client application.
+     */
+    SessionAttributes?: SessionAttribute[] | undefined;
+};
+/**
+ * Settings that specify the dialog code hook that is called by Amazon Lex between eliciting slot values.
+ */
+export type ElicitationCodeHookInvocationSetting = {
+    /**
+     * Indicates whether a Lambda function should be invoked for the dialog.
+     */
+    EnableCodeHookInvocation: boolean;
+    /**
+     * A label that indicates the dialog step from which the dialog code hook is happening.
+     */
+    InvocationLabel?: string | undefined;
+};
+/**
+ * Provides information about the external source of the slot type's definition.
+ */
+export type ExternalSourceSetting = {
+    /**
+     * Settings required for a slot type based on a grammar that you provide.
+     */
+    GrammarSlotTypeSetting?: GrammarSlotTypeSetting | undefined;
+};
+/**
+ * Determines if a Lambda function should be invoked for a specific intent.
+ */
+export type FulfillmentCodeHookSetting = {
+    /**
+     * Indicates whether a Lambda function should be invoked to fulfill a specific intent.
+     */
+    Enabled: boolean;
+    /**
+     * Provides settings for update messages sent to the user for long-running Lambda fulfillment functions. Fulfillment updates can be used only with streaming conversations.
+     */
+    FulfillmentUpdatesSpecification?: FulfillmentUpdatesSpecification | undefined;
+    /**
+     * Determines whether the fulfillment code hook is used. When `active` is false, the code hook doesn't run.
+     */
+    IsActive?: boolean | undefined;
+    /**
+     * Provides settings for messages sent to the user for after the Lambda fulfillment function completes. Post-fulfillment messages can be sent for both streaming and non-streaming conversations.
+     */
+    PostFulfillmentStatusSpecification?: PostFulfillmentStatusSpecification | undefined;
+};
+/**
+ * Provides settings for a message that is sent to the user when a fulfillment Lambda function starts running.
+ */
+export type FulfillmentStartResponseSpecification = {
+    /**
+     * Determines whether the user can interrupt the start message while it is playing.
+     */
+    AllowInterrupt?: boolean | undefined;
+    /**
+     * The delay between when the Lambda fulfillment function starts running and the start message is played. If the Lambda function returns before the delay is over, the start message isn't played.
+     * @min 1
+     * @max 900
+     */
+    DelayInSeconds: number;
+    /**
+     * 1 - 5 message groups that contain start messages. Amazon Lex chooses one of the messages to play to the user.
+     */
+    MessageGroups: MessageGroup[];
+};
+/**
+ * Provides settings for a message that is sent periodically to the user while a fulfillment Lambda function is running.
+ */
+export type FulfillmentUpdateResponseSpecification = {
+    /**
+     * Determines whether the user can interrupt an update message while it is playing.
+     */
+    AllowInterrupt?: boolean | undefined;
+    /**
+     * The frequency that a message is sent to the user. When the period ends, Amazon Lex chooses a message from the message groups and plays it to the user. If the fulfillment Lambda returns before the first period ends, an update message is not played to the user.
+     * @min 1
+     * @max 900
+     */
+    FrequencyInSeconds: number;
+    /**
+     * 1 - 5 message groups that contain update messages. Amazon Lex chooses one of the messages to play to the user.
+     */
+    MessageGroups: MessageGroup[];
+};
+/**
+ * Provides information for updating the user on the progress of fulfilling an intent.
+ */
+export type FulfillmentUpdatesSpecification = {
+    /**
+     * Determines whether fulfillment updates are sent to the user. When this field is true, updates are sent.
+     *
+     * If the `active` field is set to true, the `startResponse` , `updateResponse` , and `timeoutInSeconds` fields are required.
+     */
+    Active: boolean;
+    /**
+     * Provides configuration information for the message sent to users when the fulfillment Lambda functions starts running.
+     */
+    StartResponse?: FulfillmentStartResponseSpecification | undefined;
+    /**
+     * The length of time that the fulfillment Lambda function should run before it times out.
+     * @min 1
+     * @max 900
+     */
+    TimeoutInSeconds?: number | undefined;
+    /**
+     * Provides configuration information for messages sent periodically to the user while the fulfillment Lambda function is running.
+     */
+    UpdateResponse?: FulfillmentUpdateResponseSpecification | undefined;
+};
+/**
+ * Settings requried for a slot type based on a grammar that you provide.
+ */
+export type GrammarSlotTypeSetting = {
+    /**
+     * The source of the grammar used to create the slot type.
+     */
+    Source?: GrammarSlotTypeSource | undefined;
+};
+/**
+ * Describes the Amazon S3 bucket name and location for the grammar that is the source for the slot type.
+ */
+export type GrammarSlotTypeSource = {
+    /**
+     * The AWS KMS key required to decrypt the contents of the grammar, if any.
+     * @minLength 20
+     * @maxLength 2048
+     * @pattern ^arn:[\w\-]+:kms:[\w\-]+:[\d]{12}:(?:key\/[\w\-]+|alias\/[a-zA-Z0-9:\/_\-]{1,256})$
+     */
+    KmsKeyArn?: string | undefined;
+    /**
+     * The name of the Amazon S3 bucket that contains the grammar source.
+     */
+    S3BucketName: string;
+    /**
+     * The path to the grammar in the Amazon S3 bucket.
+     */
+    S3ObjectKey: string;
+};
+/**
+ * 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.
+ *
+ * When you use a response card, the response from the user is constrained to the text associated with a button on the card.
+ */
+export type ImageResponseCard = {
+    /**
+     * 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.
+     */
+    Buttons?: Button[] | undefined;
+    /**
+     * 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.
+     */
+    ImageUrl?: string | undefined;
+    /**
+     * The subtitle to display on the response card. The format of the subtitle is determined by the platform displaying the response card.
+     */
+    Subtitle?: string | undefined;
+    /**
+     * The title to display on the response card. The format of the title is determined by the platform displaying the response card.
+     */
+    Title: string;
+};
+/**
+ * Configuration setting for a response sent to the user before Amazon Lex starts eliciting slots.
+ */
+export type InitialResponseSetting = {
+    /**
+     * Settings that specify the dialog code hook that is called by Amazon Lex at a step of the conversation.
+     */
+    CodeHook?: DialogCodeHookInvocationSetting | undefined;
+    /**
+     * Provides a list of conditional branches. Branches are evaluated in the order that they are entered in the list. The first branch with a condition that evaluates to true is executed. The last branch in the list is the default branch. The default branch should not have any condition expression. The default branch is executed if no other branch has a matching condition.
+     */
+    Conditional?: ConditionalSpecification | undefined;
+    /**
+     * Specifies a list of message groups that Amazon Lex uses to respond the user input.
+     */
+    InitialResponse?: ResponseSpecification | undefined;
+    /**
+     * The next step in the conversation.
+     */
+    NextStep?: DialogState | undefined;
+};
+/**
+ * A context that must be active for an intent to be selected by Amazon Lex.
+ */
+export type InputContext = {
+    /**
+     * The name of the context.
+     */
+    Name: string;
+};
+/**
+ * Represents an action that the user wants to perform.
+ */
+export type Intent = {
+    BedrockAgentIntentConfiguration?: BedrockAgentIntentConfiguration | undefined;
+    /**
+     * A description of the intent. Use the description to help identify the intent in lists.
+     */
+    Description?: string | undefined;
+    /**
+     * Specifies that Amazon Lex invokes the alias Lambda function for each user input. You can invoke this Lambda function to personalize user interaction.
+     */
+    DialogCodeHook?: DialogCodeHookSetting | undefined;
+    /**
+     * Specifies that Amazon Lex invokes the alias Lambda function when the intent is ready for fulfillment. You can invoke this function to complete the bot's transaction with the user.
+     */
+    FulfillmentCodeHook?: FulfillmentCodeHookSetting | undefined;
+    /**
+     * Configuration setting for a response sent to the user before Amazon Lex starts eliciting slots.
+     */
+    InitialResponseSetting?: InitialResponseSetting | undefined;
+    /**
+     * A list of contexts that must be active for this intent to be considered by Amazon Lex .
+     */
+    InputContexts?: InputContext[] | undefined;
+    /**
+     * Sets the response that Amazon Lex sends to the user when the intent is closed.
+     */
+    IntentClosingSetting?: IntentClosingSetting | undefined;
+    /**
+     * Provides prompts that Amazon Lex sends to the user to confirm the completion of an intent. If the user answers "no," the settings contain a statement that is sent to the user to end the intent.
+     */
+    IntentConfirmationSetting?: IntentConfirmationSetting | undefined;
+    /**
+     * Provides configuration information for the `AMAZON.KendraSearchIntent` intent. When you use this intent, Amazon Lex searches the specified Amazon Kendra index and returns documents from the index that match the user's utterance.
+     */
+    KendraConfiguration?: KendraConfiguration | undefined;
+    /**
+     * The name of the intent. Intent names must be unique within the locale that contains the intent and can't match the name of any built-in intent.
+     */
+    Name: string;
+    /**
+     * A list of contexts that the intent activates when it is fulfilled.
+     */
+    OutputContexts?: OutputContext[] | undefined;
+    /**
+     * A unique identifier for the built-in intent to base this intent on.
+     */
+    ParentIntentSignature?: string | undefined;
+    QInConnectIntentConfiguration?: QInConnectIntentConfiguration | undefined;
+    QnAIntentConfiguration?: QnAIntentConfiguration | undefined;
+    /**
+     * A list of utterances that a user might say to signal the intent.
+     */
+    SampleUtterances?: SampleUtterance[] | undefined;
+    /**
+     * Indicates the priority for slots. Amazon Lex prompts the user for slot values in priority order.
+     */
+    SlotPriorities?: SlotPriority[] | undefined;
+    /**
+     * A list of slots that the intent requires for fulfillment.
+     */
+    Slots?: Slot[] | undefined;
+};
+/**
+ * Provides a statement the Amazon Lex conveys to the user when the intent is successfully fulfilled.
+ */
+export type IntentClosingSetting = {
+    /**
+     * The response that Amazon Lex sends to the user when the intent is complete.
+     */
+    ClosingResponse?: ResponseSpecification | undefined;
+    /**
+     * A list of conditional branches associated with the intent's closing response. These branches are executed when the `nextStep` attribute is set to `EvalutateConditional` .
+     */
+    Conditional?: ConditionalSpecification | undefined;
+    /**
+     * Specifies whether an intent's closing response is used. When this field is false, the closing response isn't sent to the user. If the `IsActive` field isn't specified, the default is true.
+     */
+    IsActive?: boolean | undefined;
+    /**
+     * Specifies the next step that the bot executes after playing the intent's closing response.
+     */
+    NextStep?: DialogState | undefined;
+};
+/**
+ * Provides a prompt for making sure that the user is ready for the intent to be fulfilled.
+ */
+export type IntentConfirmationSetting = {
+    /**
+     * The `DialogCodeHookInvocationSetting` object associated with intent's confirmation step. The dialog code hook is triggered based on these invocation settings when the confirmation next step or declination next step or failure next step is `InvokeDialogCodeHook` .
+     */
+    CodeHook?: DialogCodeHookInvocationSetting | undefined;
+    /**
+     * A list of conditional branches to evaluate after the intent is closed.
+     */
+    ConfirmationConditional?: ConditionalSpecification | undefined;
+    /**
+     * Specifies the next step that the bot executes when the customer confirms the intent.
+     */
+    ConfirmationNextStep?: DialogState | undefined;
+    /**
+     * Specifies a list of message groups that Amazon Lex uses to respond the user input.
+     */
+    ConfirmationResponse?: ResponseSpecification | undefined;
+    /**
+     * A list of conditional branches to evaluate after the intent is declined.
+     */
+    DeclinationConditional?: ConditionalSpecification | undefined;
+    /**
+     * Specifies the next step that the bot executes when the customer declines the intent.
+     */
+    DeclinationNextStep?: DialogState | undefined;
+    /**
+     * When the user answers "no" to the question defined in `promptSpecification` , Amazon Lex responds with this response to acknowledge that the intent was canceled.
+     */
+    DeclinationResponse?: ResponseSpecification | undefined;
+    /**
+     * The `DialogCodeHookInvocationSetting` used when the code hook is invoked during confirmation prompt retries.
+     */
+    ElicitationCodeHook?: ElicitationCodeHookInvocationSetting | undefined;
+    /**
+     * Provides a list of conditional branches. Branches are evaluated in the order that they are entered in the list. The first branch with a condition that evaluates to true is executed. The last branch in the list is the default branch. The default branch should not have any condition expression. The default branch is executed if no other branch has a matching condition.
+     */
+    FailureConditional?: ConditionalSpecification | undefined;
+    /**
+     * The next step to take in the conversation if the confirmation step fails.
+     */
+    FailureNextStep?: DialogState | undefined;
+    /**
+     * Specifies a list of message groups that Amazon Lex uses to respond the user input when the intent confirmation fails.
+     */
+    FailureResponse?: ResponseSpecification | undefined;
+    /**
+     * Specifies whether the intent's confirmation is sent to the user. When this field is false, confirmation and declination responses aren't sent. If the `IsActive` field isn't specified, the default is true.
+     */
+    IsActive?: boolean | undefined;
+    /**
+     * Prompts the user to confirm the intent. This question should have a yes or no answer.
+     *
+     * Amazon Lex uses this prompt to ensure that the user acknowledges that the intent is ready for fulfillment. For example, with the `OrderPizza` intent, you might want to confirm that the order is correct before placing it. For other intents, such as intents that simply respond to user questions, you might not need to ask the user for confirmation before providing the information.
+     */
+    PromptSpecification: PromptSpecification;
+};
+/**
+ * Override settings to configure the intent state.
+ */
+export type IntentOverride = {
+    /**
+     * The name of the intent. Only required when you're switching intents.
+     */
+    Name?: string | undefined;
+    /**
+     * A map of all of the slot value overrides for the intent. The name of the slot maps to the value of the slot. Slots that are not included in the map aren't overridden.
+     */
+    Slots?: SlotValueOverrideMap[] | undefined;
+};
+/**
+ * Provides configuration information for the `AMAZON.KendraSearchIntent` intent. When you use this intent, Amazon Lex searches the specified Amazon Kendra index and returns documents from the index that match the user's utterance.
+ */
+export type KendraConfiguration = {
+    /**
+     * The Amazon Resource Name (ARN) of the Amazon Kendra index that you want the `AMAZON.KendraSearchIntent` intent to search. The index must be in the same account and Region as the Amazon Lex bot.
+     */
+    KendraIndex: string;
+    /**
+     * A query filter that Amazon Lex sends to Amazon Kendra to filter the response from a query. The filter is in the format defined by Amazon Kendra. For more information, see [Filtering queries](https://docs.aws.amazon.com/kendra/latest/dg/filtering.html) .
+     */
+    QueryFilterString?: string | undefined;
+    /**
+     * Determines whether the `AMAZON.KendraSearchIntent` intent uses a custom query string to query the Amazon Kendra index.
+     */
+    QueryFilterStringEnabled?: boolean | undefined;
+};
+/**
+ * Specifies a Lambda function that verifies requests to a bot or fulfills the user's request to a bot.
+ */
+export type LambdaCodeHook = {
+    /**
+     * The version of the request-response that you want Amazon Lex to use to invoke your Lambda function.
+     * @minLength 1
+     * @maxLength 5
+     */
+    CodeHookInterfaceVersion: string;
+    /**
+     * The Amazon Resource Name (ARN) of the Lambda function.
+     * @minLength 20
+     * @maxLength 2048
+     */
+    LambdaArn: string;
+};
+/**
+ * The object that provides message text and its type.
+ */
+export type Message = {
+    /**
+     * A message in a custom format defined by the client application.
+     */
+    CustomPayload?: CustomPayload | undefined;
+    /**
+     * A message that defines a response card that the client application can show to the user.
+     */
+    ImageResponseCard?: ImageResponseCard | undefined;
+    /**
+     * A message in plain text format.
+     */
+    PlainTextMessage?: PlainTextMessage | undefined;
+    /**
+     * A message in Speech Synthesis Markup Language (SSML).
+     */
+    SSMLMessage?: SSMLMessage | undefined;
+};
+/**
+ * Provides one or more messages that Amazon Lex should send to the user.
+ */
+export type MessageGroup = {
+    /**
+     * The primary message that Amazon Lex should send to the user.
+     */
+    Message: Message;
+    /**
+     * Message variations to send to the user. When variations are defined, Amazon Lex chooses the primary message or one of the variations to send to the user.
+     */
+    Variations?: Message[] | undefined;
+};
+export type MessageSelectionStrategy = "Random" | "Ordered";
+/**
+ * Indicates whether a slot can return multiple values.
+ */
+export type MultipleValuesSetting = {
+    /**
+     * Indicates whether a slot can return multiple values. When `true` , the slot may return more than one value in a response. When `false` , the slot returns only a single value.
+     *
+     * Multi-value slots are only available in the en-US locale. If you set this value to `true` in any other locale, Amazon Lex throws a `ValidationException` .
+     *
+     * If the `allowMutlipleValues` is not set, the default value is `false` .
+     */
+    AllowMultipleValues?: boolean | undefined;
+};
+/**
+ * Determines whether Amazon Lex obscures slot values in conversation logs.
+ */
+export type ObfuscationSetting = {
+    /**
+     * Value that determines whether Amazon Lex obscures slot values in conversation logs. The default is to obscure the values.
+     */
+    ObfuscationSettingType: "None" | "DefaultObfuscation";
+};
+/**
+ * Describes a session context that is activated when an intent is fulfilled.
+ */
+export type OutputContext = {
+    /**
+     * The name of the output context.
+     */
+    Name: string;
+    /**
+     * The amount of time, in seconds, that the output context should remain active. The time is figured from the first time the context is sent to the user.
+     */
+    TimeToLiveInSeconds: number;
+    /**
+     * The number of conversation turns that the output context should remain active. The number of turns is counted from the first time that the context is sent to the user.
+     */
+    TurnsToLive: number;
+};
+/**
+ * Defines an ASCII text message to send to the user.
+ */
+export type PlainTextMessage = {
+    /**
+     * The message to send to the user.
+     * @minLength 1
+     * @maxLength 1000
+     */
+    Value: string;
+};
+/**
+ * Specifies next steps to run after the dialog code hook finishes.
+ */
+export type PostDialogCodeHookInvocationSpecification = {
+    /**
+     * A list of conditional branches to evaluate after the dialog code hook throws an exception or returns with the `State` field of the `Intent` object set to `Failed` .
+     */
+    FailureConditional?: ConditionalSpecification | undefined;
+    /**
+     * Specifies the next step the bot runs after the dialog code hook throws an exception or returns with the `State` field of the `Intent` object set to `Failed` .
+     */
+    FailureNextStep?: DialogState | undefined;
+    /**
+     * Specifies a list of message groups that Amazon Lex uses to respond the user input when the code hook fails.
+     */
+    FailureResponse?: ResponseSpecification | undefined;
+    /**
+     * A list of conditional branches to evaluate after the dialog code hook finishes successfully.
+     */
+    SuccessConditional?: ConditionalSpecification | undefined;
+    /**
+     * Specifics the next step the bot runs after the dialog code hook finishes successfully.
+     */
+    SuccessNextStep?: DialogState | undefined;
+    /**
+     * Specifies a list of message groups that Amazon Lex uses to respond when the code hook succeeds.
+     */
+    SuccessResponse?: ResponseSpecification | undefined;
+    /**
+     * A list of conditional branches to evaluate if the code hook times out.
+     */
+    TimeoutConditional?: ConditionalSpecification | undefined;
+    /**
+     * Specifies the next step that the bot runs when the code hook times out.
+     */
+    TimeoutNextStep?: DialogState | undefined;
+    /**
+     * Specifies a list of message groups that Amazon Lex uses to respond to the user input when the code hook times out.
+     */
+    TimeoutResponse?: ResponseSpecification | undefined;
+};
+/**
+ * Provides a setting that determines whether the post-fulfillment response is sent to the user. For more information, see [](https://docs.aws.amazon.com/lexv2/latest/dg/streaming-progress.html#progress-complete)
+ */
+export type PostFulfillmentStatusSpecification = {
+    /**
+     * A list of conditional branches to evaluate after the fulfillment code hook throws an exception or returns with the `State` field of the `Intent` object set to `Failed` .
+     */
+    FailureConditional?: ConditionalSpecification | undefined;
+    /**
+     * Specifies the next step the bot runs after the fulfillment code hook throws an exception or returns with the `State` field of the `Intent` object set to `Failed` .
+     */
+    FailureNextStep?: DialogState | undefined;
+    /**
+     * Specifies a list of message groups that Amazon Lex uses to respond when fulfillment isn't successful.
+     */
+    FailureResponse?: ResponseSpecification | undefined;
+    /**
+     * A list of conditional branches to evaluate after the fulfillment code hook finishes successfully.
+     */
+    SuccessConditional?: ConditionalSpecification | undefined;
+    /**
+     * Specifies the next step in the conversation that Amazon Lex invokes when the fulfillment code hook completes successfully.
+     */
+    SuccessNextStep?: DialogState | undefined;
+    /**
+     * Specifies a list of message groups that Amazon Lex uses to respond when the fulfillment is successful.
+     */
+    SuccessResponse?: ResponseSpecification | undefined;
+    /**
+     * A list of conditional branches to evaluate if the fulfillment code hook times out.
+     */
+    TimeoutConditional?: ConditionalSpecification | undefined;
+    /**
+     * Specifies the next step that the bot runs when the fulfillment code hook times out.
+     */
+    TimeoutNextStep?: DialogState | undefined;
+    /**
+     * Specifies a list of message groups that Amazon Lex uses to respond when fulfillment isn't completed within the timeout period.
+     */
+    TimeoutResponse?: ResponseSpecification | undefined;
+};
+/**
+ * Specifies the settings on a prompt attempt.
+ */
+export type PromptAttemptSpecification = {
+    /**
+     * Indicates whether the user can interrupt a speech prompt attempt from the bot.
+     */
+    AllowInterrupt?: boolean | undefined;
+    /**
+     * Indicates the allowed input types of the prompt attempt.
+     */
+    AllowedInputTypes: AllowedInputTypes;
+    /**
+     * Specifies the settings on audio and DTMF input.
+     */
+    AudioAndDTMFInputSpecification?: AudioAndDTMFInputSpecification | undefined;
+    /**
+     * Specifies the settings on text input.
+     */
+    TextInputSpecification?: TextInputSpecification | undefined;
+};
+/**
+ * Specifies a list of message groups that Amazon Lex sends to a user to elicit a response.
+ */
+export type PromptSpecification = {
+    /**
+     * Indicates whether the user can interrupt a speech prompt from the bot.
+     */
+    AllowInterrupt?: boolean | undefined;
+    /**
+     * The maximum number of times the bot tries to elicit a response from the user using this prompt.
+     */
+    MaxRetries: number;
+    /**
+     * A collection of messages that Amazon Lex can send to the user. Amazon Lex chooses the actual message to send at runtime.
+     */
+    MessageGroupsList: MessageGroup[];
+    /**
+     * Indicates how a message is selected from a message group among retries.
+     */
+    MessageSelectionStrategy?: MessageSelectionStrategy | undefined;
+    /**
+     * Specifies the advanced settings on each attempt of the prompt.
+     */
+    PromptAttemptsSpecification?: Record<string, PromptAttemptSpecification> | undefined;
+};
+export type QInConnectIntentConfiguration = {
+    QInConnectAssistantConfiguration?: {
+        /**
+         * @minLength 1
+         * @maxLength 200
+         * @pattern ^arn:[a-z-]*?:wisdom:[a-z0-9-]*?:[0-9]{12}:[a-z-]*?/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}(?:/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}){0,2}$
+         */
+        AssistantArn: string;
+    } | undefined;
+};
+/**
+ * Details about the the configuration of the built-in `Amazon.QnAIntent` .
+ */
+export type QnAIntentConfiguration = {
+    BedrockModelConfiguration: BedrockModelSpecification;
+    /**
+     * Contains details about the configuration of the data source used for the `AMAZON.QnAIntent` .
+     */
+    DataSourceConfiguration: {
+        BedrockKnowledgeStoreConfiguration?: {
+            BKBExactResponseFields?: {
+                /**
+                 * @minLength 1
+                 * @maxLength 5000
+                 */
+                AnswerField?: string | undefined;
+            } | undefined;
+            /**
+             * @minLength 1
+             * @maxLength 5000
+             */
+            BedrockKnowledgeBaseArn?: string | undefined;
+            ExactResponse?: boolean | undefined;
+        } | undefined;
+        KendraConfiguration?: QnAKendraConfiguration | undefined;
+        OpensearchConfiguration?: {
+            /**
+             * @minLength 1
+             * @maxLength 5000
+             */
+            DomainEndpoint?: string | undefined;
+            ExactResponse?: boolean | undefined;
+            ExactResponseFields?: {
+                /**
+                 * @minLength 1
+                 * @maxLength 5000
+                 */
+                AnswerField?: string | undefined;
+                /**
+                 * @minLength 1
+                 * @maxLength 5000
+                 */
+                QuestionField?: string | undefined;
+            } | undefined;
+            IncludeFields?: string[] | undefined;
+            /**
+             * @minLength 1
+             * @maxLength 5000
+             */
+            IndexName?: string | undefined;
+        } | undefined;
+    };
+};
+/**
+ * Contains details about the configuration of the Amazon Kendra index used for the `AMAZON.QnAIntent` .
+ */
+export type QnAKendraConfiguration = {
+    /**
+     * Specifies whether to return an exact response from the Amazon Kendra index or to let the Amazon Bedrock model you select generate a response based on the results. To use this feature, you must first add FAQ questions to your index by following the steps at [Adding frequently asked questions (FAQs) to an index](https://docs.aws.amazon.com/kendra/latest/dg/in-creating-faq.html) .
+     */
+    ExactResponse: boolean;
+    /**
+     * The ARN of the Amazon Kendra index to use.
+     * @minLength 1
+     * @maxLength 5000
+     */
+    KendraIndex: string;
+    /**
+     * Contains the Amazon Kendra filter string to use if enabled. For more information on the Amazon Kendra search filter JSON format, see [Using document attributes to filter search results](https://docs.aws.amazon.com/kendra/latest/dg/filtering.html#search-filtering) .
+     * @minLength 1
+     * @maxLength 5000
+     */
+    QueryFilterString?: string | undefined;
+    /**
+     * Specifies whether to enable an Amazon Kendra filter string or not.
+     */
+    QueryFilterStringEnabled: boolean;
+};
+export type Replication = {
+    ReplicaRegions: string[];
+};
+/**
+ * Specifies a list of message groups that Amazon Lex uses to respond the user input.
+ */
+export type ResponseSpecification = {
+    /**
+     * Indicates whether the user can interrupt a speech response from Amazon Lex.
+     */
+    AllowInterrupt?: boolean | undefined;
+    /**
+     * A collection of responses that Amazon Lex can send to the user. Amazon Lex chooses the actual response to send at runtime.
+     */
+    MessageGroupsList: MessageGroup[];
+};
+/**
+ * Specifies an Amazon S3 bucket for logging audio conversations
+ */
+export type S3BucketLogDestination = {
+    /**
+     * The Amazon Resource Name (ARN) of an AWS Key Management Service (KMS) key for encrypting audio log files stored in an Amazon S3 bucket.
+     * @minLength 20
+     * @maxLength 2048
+     * @pattern ^arn:[\w\-]+:kms:[\w\-]+:[\d]{12}:(?:key\/[\w\-]+|alias\/[a-zA-Z0-9:\/_\-]{1,256})$
+     */
+    KmsKeyArn?: string | undefined;
+    /**
+     * The S3 prefix to assign to audio log files.
+     * @minLength 0
+     * @maxLength 1024
+     */
+    LogPrefix: string;
+    /**
+     * The Amazon Resource Name (ARN) of an Amazon S3 bucket where audio log files are stored.
+     * @minLength 1
+     * @maxLength 2048
+     * @pattern ^arn:[\w\-]+:s3:::[a-z0-9][\.\-a-z0-9]{1,61}[a-z0-9]$
+     */
+    S3BucketArn: string;
+};
+/**
+ * Defines an Amazon S3 bucket location.
+ */
+export type S3Location = {
+    /**
+     * The S3 bucket name.
+     */
+    S3Bucket: string;
+    /**
+     * The path and file name to the object in the S3 bucket.
+     */
+    S3ObjectKey: string;
+    /**
+     * The version of the object in the S3 bucket.
+     * @minLength 1
+     * @maxLength 1024
+     */
+    S3ObjectVersion?: string | undefined;
+};
+/**
+ * Defines a Speech Synthesis Markup Language (SSML) prompt.
+ */
+export type SSMLMessage = {
+    /**
+     * The SSML text that defines the prompt.
+     * @minLength 1
+     * @maxLength 1000
+     */
+    Value: string;
+};
+/**
+ * A sample utterance that invokes an intent or respond to a slot elicitation prompt.
+ */
+export type SampleUtterance = {
+    /**
+     * A sample utterance that invokes an intent or respond to a slot elicitation prompt.
+     */
+    Utterance: string;
+};
+/**
+ * Defines one of the values for a slot type.
+ */
+export type SampleValue = {
+    /**
+     * The value that can be used for a slot type.
+     * @minLength 1
+     * @maxLength 140
+     */
+    Value: string;
+};
+/**
+ * A key/value pair representing session-specific context information. It contains application information passed between Amazon Lex V2 and a client application.
+ */
+export type SessionAttribute = {
+    /**
+     * The name of the session attribute.
+     * @minLength 1
+     * @maxLength 1024
+     */
+    Key: string;
+    /**
+     * The session-specific context information for the session attribute.
+     * @minLength 0
+     * @maxLength 1024
+     */
+    Value?: string | undefined;
+};
+/**
+ * Specifies the definition of a slot. Amazon Lex elicits slot values from uses to fulfill the user's intent.
+ */
+export type Slot = {
+    /**
+     * The description of the slot.
+     */
+    Description?: string | undefined;
+    /**
+     * Indicates whether a slot can return multiple values.
+     */
+    MultipleValuesSetting?: MultipleValuesSetting | undefined;
+    /**
+     * The name given to the slot.
+     */
+    Name: string;
+    /**
+     * Determines whether the contents of the slot are obfuscated in Amazon CloudWatch Logs logs. Use obfuscated slots to protect information such as personally identifiable information (PII) in logs.
+     */
+    ObfuscationSetting?: ObfuscationSetting | undefined;
+    /**
+     * The name of the slot type that this slot is based on. The slot type defines the acceptable values for the slot.
+     */
+    SlotTypeName: string;
+    /**
+     * Determines the slot resolution strategy that Amazon Lex uses to return slot type values. The field can be set to one of the following values:
+     *
+     * - ORIGINAL_VALUE - Returns the value entered by the user, if the user value is similar to a slot value.
+     * - TOP_RESOLUTION - If there is a resolution list for the slot, return the first value in the resolution list as the slot type value. If there is no resolution list, null is returned.
+     *
+     * If you don't specify the `valueSelectionStrategy` , the default is `ORIGINAL_VALUE` .
+     */
+    ValueElicitationSetting: SlotValueElicitationSetting;
+};
+/**
+ * Settings used when Amazon Lex successfully captures a slot value from a user.
+ */
+export type SlotCaptureSetting = {
+    /**
+     * A list of conditional branches to evaluate after the slot value is captured.
+     */
+    CaptureConditional?: ConditionalSpecification | undefined;
+    /**
+     * Specifies the next step that the bot runs when the slot value is captured before the code hook times out.
+     */
+    CaptureNextStep?: DialogState | undefined;
+    /**
+     * Specifies a list of message groups that Amazon Lex uses to respond the user input.
+     */
+    CaptureResponse?: ResponseSpecification | undefined;
+    /**
+     * Code hook called after Amazon Lex successfully captures a slot value.
+     */
+    CodeHook?: DialogCodeHookInvocationSetting | undefined;
+    /**
+     * Code hook called when Amazon Lex doesn't capture a slot value.
+     */
+    ElicitationCodeHook?: ElicitationCodeHookInvocationSetting | undefined;
+    /**
+     * A list of conditional branches to evaluate when the slot value isn't captured.
+     */
+    FailureConditional?: ConditionalSpecification | undefined;
+    /**
+     * Specifies the next step that the bot runs when the slot value code is not recognized.
+     */
+    FailureNextStep?: DialogState | undefined;
+    /**
+     * Specifies a list of message groups that Amazon Lex uses to respond the user input when the slot fails to be captured.
+     */
+    FailureResponse?: ResponseSpecification | undefined;
+};
+export type SlotConstraint = "Required" | "Optional";
+/**
+ * Specifies the default value to use when a user doesn't provide a value for a slot.
+ */
+export type SlotDefaultValue = {
+    /**
+     * The default value to use when a user doesn't provide a value for a slot.
+     * @minLength 1
+     * @maxLength 202
+     */
+    DefaultValue: string;
+};
+/**
+ * The default value to use when a user doesn't provide a value for a slot.
+ */
+export type SlotDefaultValueSpecification = {
+    /**
+     * A list of default values. Amazon Lex chooses the default value to use in the order that they are presented in the list.
+     */
+    DefaultValueList: SlotDefaultValue[];
+};
+/**
+ * Sets the priority that Amazon Lex should use when eliciting slot values from a user.
+ */
+export type SlotPriority = {
+    /**
+     * The priority that Amazon Lex should apply to the slot.
+     */
+    Priority: number;
+    /**
+     * The name of the slot.
+     */
+    SlotName: string;
+};
+export type SlotShape = "Scalar" | "List";
+/**
+ * Describes a slot type.
+ */
+export type SlotType = {
+    CompositeSlotTypeSetting?: CompositeSlotTypeSetting | undefined;
+    /**
+     * A description of the slot type. Use the description to help identify the slot type in lists.
+     */
+    Description?: string | undefined;
+    /**
+     * Sets the type of external information used to create the slot type.
+     */
+    ExternalSourceSetting?: ExternalSourceSetting | undefined;
+    /**
+     * The name of the slot type. A slot type name must be unique withing the account.
+     */
+    Name: string;
+    /**
+     * The built-in slot type used as a parent of this slot type. When you define a parent slot type, the new slot type has the configuration of the parent lot type.
+     *
+     * Only `AMAZON.AlphaNumeric` is supported.
+     */
+    ParentSlotTypeSignature?: string | undefined;
+    /**
+     * A list of SlotTypeValue objects that defines the values that the slot type can take. Each value can have a list of synonyms, additional values that help train the machine learning model about the values that it resolves for the slot.
+     */
+    SlotTypeValues?: SlotTypeValue[] | undefined;
+    /**
+     * Determines the slot resolution strategy that Amazon Lex uses to return slot type values. The field can be set to one of the following values:
+     *
+     * - `ORIGINAL_VALUE` - Returns the value entered by the user, if the user value is similar to the slot value.
+     * - `TOP_RESOLUTION` - If there is a resolution list for the slot, return the first value in the resolution list as the slot type value. If there is no resolution list, null is returned.
+     *
+     * If you don't specify the `valueSelectionStrategy` , the default is `ORIGINAL_VALUE` .
+     */
+    ValueSelectionSetting?: SlotValueSelectionSetting | undefined;
+};
+/**
+ * Each slot type can have a set of values. Each `SlotTypeValue` represents a value that the slot type can take.
+ */
+export type SlotTypeValue = {
+    /**
+     * The value of the slot type entry.
+     */
+    SampleValue: SampleValue;
+    /**
+     * Additional values related to the slot type entry.
+     */
+    Synonyms?: SampleValue[] | undefined;
+};
+/**
+ * The value to set in a slot.
+ */
+export type SlotValue = {
+    /**
+     * The value that Amazon Lex 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 choose the first value in the `resolvedValues` list.
+     * @minLength 1
+     * @maxLength 202
+     */
+    InterpretedValue?: string | undefined;
+};
+/**
+ * Specifies the elicitation setting details eliciting a slot.
+ */
+export type SlotValueElicitationSetting = {
+    /**
+     * A list of default values for a slot. Default values are used when Amazon Lex hasn't determined a value for a slot. You can specify default values from context variables, session attributes, and defined values.
+     */
+    DefaultValueSpecification?: SlotDefaultValueSpecification | undefined;
+    /**
+     * The prompt that Amazon Lex uses to elicit the slot value from the user.
+     */
+    PromptSpecification?: PromptSpecification | undefined;
+    /**
+     * If you know a specific pattern that users might respond to an Amazon Lex request for a slot value, you can provide those utterances to improve accuracy. This is optional. In most cases, Amazon Lex is capable of understanding user utterances.
+     */
+    SampleUtterances?: SampleUtterance[] | undefined;
+    /**
+     * Specifies the settings that Amazon Lex uses when a slot value is successfully entered by a user.
+     */
+    SlotCaptureSetting?: SlotCaptureSetting | undefined;
+    /**
+     * Specifies whether the slot is required or optional.
+     */
+    SlotConstraint: SlotConstraint;
+    /**
+     * Specifies the prompts that Amazon Lex uses while a bot is waiting for customer input.
+     */
+    WaitAndContinueSpecification?: WaitAndContinueSpecification | undefined;
+};
+/**
+ * The slot values that Amazon Lex uses when it sets slot values in a dialog step.
+ */
+export type SlotValueOverride = {
+    /**
+     * When the shape value is `List` , it indicates that the `values` field contains a list of slot values. When the value is `Scalar` , it indicates that the `value` field contains a single value.
+     */
+    Shape?: SlotShape | undefined;
+    /**
+     * The current value of the slot.
+     */
+    Value?: SlotValue | undefined;
+    /**
+     * A list of one or more values that the user provided for the slot. For example, for a slot that elicits pizza toppings, the values might be "pepperoni" and "pineapple."
+     */
+    Values?: SlotValueOverride[] | undefined;
+};
+/**
+ * Maps a slot name to the [SlotValueOverride](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_SlotValueOverride.html) object.
+ */
+export type SlotValueOverrideMap = {
+    /**
+     * The name of the slot.
+     */
+    SlotName?: string | undefined;
+    /**
+     * The SlotValueOverride object to which the slot name will be mapped.
+     */
+    SlotValueOverride?: SlotValueOverride | undefined;
+};
+/**
+ * Provides a regular expression used to validate the value of a slot.
+ */
+export type SlotValueRegexFilter = {
+    /**
+     * A regular expression used to validate the value of a slot.
+     *
+     * Use a standard regular expression. Amazon Lex supports the following characters in the regular expression:
+     *
+     * - A-Z, a-z
+     * - 0-9
+     * - Unicode characters ("\⁠u<Unicode>")
+     *
+     * Represent Unicode characters with four digits, for example "\⁠u0041" or "\⁠u005A".
+     *
+     * The following regular expression operators are not supported:
+     *
+     * - Infinite repeaters: *, +, or {x,} with no upper bound.
+     * - Wild card (.)
+     * @minLength 1
+     * @maxLength 300
+     */
+    Pattern: string;
+};
+export type SlotValueResolutionStrategy = "ORIGINAL_VALUE" | "TOP_RESOLUTION" | "CONCATENATION";
+/**
+ * Contains settings used by Amazon Lex to select a slot value.
+ */
+export type SlotValueSelectionSetting = {
+    /**
+     * Provides settings that enable advanced recognition settings for slot values. You can use this to enable using slot values as a custom vocabulary for recognizing user utterances.
+     */
+    AdvancedRecognitionSetting?: AdvancedRecognitionSetting | undefined;
+    /**
+     * A regular expression used to validate the value of a slot.
+     */
+    RegexFilter?: SlotValueRegexFilter | undefined;
+    /**
+     * Determines the slot resolution strategy that Amazon Lex uses to return slot type values. The field can be set to one of the following values:
+     *
+     * - `ORIGINAL_VALUE` - Returns the value entered by the user, if the user value is similar to the slot value.
+     * - `TOP_RESOLUTION` - If there is a resolution list for the slot, return the first value in the resolution list as the slot type value. If there is no resolution list, null is returned.
+     *
+     * If you don't specify the `valueSelectionStrategy` , the default is `ORIGINAL_VALUE` .
+     */
+    ResolutionStrategy: SlotValueResolutionStrategy;
+};
+/**
+ * Defines the messages that Amazon Lex sends to a user to remind them that the bot is waiting for a response.
+ */
+export type StillWaitingResponseSpecification = {
+    /**
+     * Indicates that the user can interrupt the response by speaking while the message is being played.
+     */
+    AllowInterrupt?: boolean | undefined;
+    /**
+     * How often a message should be sent to the user. Minimum of 1 second, maximum of 5 minutes.
+     */
+    FrequencyInSeconds: number;
+    /**
+     * One or more message groups, each containing one or more messages, that define the prompts that Amazon Lex sends to the user.
+     */
+    MessageGroupsList: MessageGroup[];
+    /**
+     * If Amazon Lex waits longer than this length of time for a response, it will stop sending messages.
+     */
+    TimeoutInSeconds: number;
+};
+/**
+ * Subslot type composition.
+ */
+export type SubSlotTypeComposition = {
+    /**
+     * Name of a constituent sub slot inside a composite slot.
+     * @minLength 1
+     * @maxLength 100
+     * @pattern ^([0-9a-zA-Z][_-]?){1,100}$
+     */
+    Name: string;
+    /**
+     * The unique identifier assigned to a slot type. This refers to either a built-in slot type or the unique slotTypeId of a custom slot type.
+     * @minLength 1
+     * @maxLength 25
+     * @pattern ^((AMAZON\.)[a-zA-Z_]+?|[0-9a-zA-Z]+)$
+     */
+    SlotTypeId: string;
+};
+/**
+ * Specifies configuration settings for the alias used to test the bot. If the `TestBotAliasSettings` property is not specified, the settings are configured with default values.
+ */
+export type TestBotAliasSettings = {
+    /**
+     * Specifies settings that are unique to a locale. For example, you can use a different Lambda function depending on the bot's locale.
+     */
+    BotAliasLocaleSettings?: BotAliasLocaleSettingsItem[] | undefined;
+    /**
+     * Specifies settings for conversation logs that save audio, text, and metadata information for conversations with your users.
+     */
+    ConversationLogSettings?: ConversationLogSettings | undefined;
+    /**
+     * Specifies a description for the test bot alias.
+     */
+    Description?: string | undefined;
+    /**
+     * Specifies whether Amazon Lex will use Amazon Comprehend to detect the sentiment of user utterances.
+     */
+    SentimentAnalysisSettings?: {
+        DetectSentiment: boolean;
+    } | undefined;
+};
+/**
+ * Specifies the text input specifications.
+ */
+export type TextInputSpecification = {
+    /**
+     * Time for which a bot waits before re-prompting a customer for text input.
+     * @min 1
+     */
+    StartTimeoutMs: number;
+};
+/**
+ * Defines the Amazon CloudWatch Logs destination log group for conversation text logs.
+ */
+export type TextLogDestination = {
+    /**
+     * Defines the Amazon CloudWatch Logs log group where text and metadata logs are delivered.
+     */
+    CloudWatch: CloudWatchLogGroupLogDestination;
+};
+/**
+ * Defines settings to enable text conversation logs.
+ */
+export type TextLogSetting = {
+    /**
+     * Specifies the Amazon CloudWatch Logs destination log group for conversation text logs.
+     */
+    Destination: TextLogDestination;
+    /**
+     * Determines whether conversation logs should be stored for an alias.
+     */
+    Enabled: boolean;
+};
+/**
+ * Defines settings for using an Amazon Polly voice to communicate with a user.
+ *
+ * Valid values include:
+ *
+ * - `standard`
+ * - `neural`
+ * - `long-form`
+ * - `generative`
+ */
+export type VoiceSettings = {
+    /**
+     * Indicates the type of Amazon Polly voice that Amazon Lex should use for voice interaction with the user. For more information, see the [`engine` parameter of the `SynthesizeSpeech` operation](https://docs.aws.amazon.com/polly/latest/dg/API_SynthesizeSpeech.html#polly-SynthesizeSpeech-request-Engine) in the *Amazon Polly developer guide* .
+     *
+     * If you do not specify a value, the default is `standard` .
+     */
+    Engine?: "standard" | "neural" | "long-form" | "generative" | undefined;
+    /**
+     * The identifier of the Amazon Polly voice to use.
+     */
+    VoiceId: string;
+};
+/**
+ * Specifies the prompts that Amazon Lex uses while a bot is waiting for customer input.
+ */
+export type WaitAndContinueSpecification = {
+    /**
+     * The response that Amazon Lex sends to indicate that the bot is ready to continue the conversation.
+     */
+    ContinueResponse: ResponseSpecification;
+    /**
+     * Specifies whether the bot will wait for a user to respond. When this field is false, wait and continue responses for a slot aren't used. If the `IsActive` field isn't specified, the default is true.
+     */
+    IsActive?: boolean | undefined;
+    /**
+     * A response that Amazon Lex sends periodically to the user to indicate that the bot is still waiting for input from the user.
+     */
+    StillWaitingResponse?: StillWaitingResponseSpecification | undefined;
+    /**
+     * The response that Amazon Lex sends to indicate that the bot is waiting for the conversation to continue.
+     */
+    WaitingResponse: ResponseSpecification;
+};
+//# sourceMappingURL=aws-lex-bot.d.ts.map