Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that Amazon Lex Model Building Service can respond with.

Structs

BotAliasMetadata

Provides information about a bot alias.

BotChannelAssociation

Represents an association between an Amazon Lex bot and an external messaging platform.

BotMetadata

Provides information about a bot. .

BuiltinIntentMetadata

Provides metadata for a built-in intent.

BuiltinIntentSlot

Provides information about a slot used in a built-in intent.

BuiltinSlotTypeMetadata

Provides information about a built in slot type.

CodeHook

Specifies a Lambda function that verifies requests to a bot or fulfills the user's request to a bot..

ConversationLogsRequest

Provides the settings needed for conversation logs.

ConversationLogsResponse

Contains information about conversation log settings.

EnumerationValue

Each slot type can have a set of values. Each enumeration value represents a value the slot type can take.

For example, a pizza ordering bot could have a slot type that specifies the type of crust that the pizza should have. The slot type could include the values

• thick

• thin

• stuffed

FollowUpPrompt

A prompt for additional activity after an intent is fulfilled. For example, after the OrderPizza intent is fulfilled, you might prompt the user to find out whether the user wants to order drinks.

FulfillmentActivity

Describes how the intent is fulfilled after the user provides all of the information required for the intent. You can provide a Lambda function to process the intent, or you can return the intent information to the client application. We recommend that you use a Lambda function so that the relevant logic lives in the Cloud and limit the client-side code primarily to presentation. If you need to update the logic, you only update the Lambda function; you don't need to upgrade your client application.

Consider the following examples:

• In a pizza ordering application, after the user provides all of the information for placing an order, you use a Lambda function to place an order with a pizzeria.

• In a gaming application, when a user says "pick up a rock," this information must go back to the client application so that it can perform the operation and update the graphics. In this case, you want Amazon Lex to return the intent data to the client.

InputContext

The name of a context that must be active for an intent to be selected by Amazon Lex.

Intent

Identifies the specific version of an intent.

IntentMetadata

Provides information about an intent.

KendraConfiguration

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. For more information, see AMAZON.KendraSearchIntent.

LogSettingsRequest

Settings used to configure delivery mode and destination for conversation logs.

LogSettingsResponse

The settings for conversation logs.

Message

The message object that provides the message text and its type.

MigrationAlert

Provides information about alerts and warnings that Amazon Lex sends during a migration. The alerts include information about how to resolve the issue.

MigrationSummary

Provides information about migrating a bot from Amazon Lex V1 to Amazon Lex V2.

OutputContext

The specification of an output context that is set when an intent is fulfilled.

Prompt

Obtains information from the user. To define a prompt, provide one or more messages and specify the number of attempts to get information from the user. If you provide more than one message, Amazon Lex chooses one of the messages to use to prompt the user. For more information, see how-it-works.

ResourceReference

Describes the resource that refers to the resource that you are attempting to delete. This object is returned as part of the ResourceInUseException exception.

Slot

Identifies the version of a specific slot.

SlotDefaultValue

A default value for a slot.

SlotDefaultValueSpec

Contains the default values for a slot. Default values are used when Amazon Lex hasn't determined a value for a slot.

SlotTypeConfiguration

Provides configuration information for a slot type.

SlotTypeMetadata

Provides information about a slot type..

SlotTypeRegexConfiguration

Provides a regular expression used to validate the value of a slot.

Statement

A collection of messages that convey information to the user. At runtime, Amazon Lex selects the message to convey.

Tag

A list of key/value pairs that identify a bot, bot alias, or bot channel. Tag keys and values can consist of Unicode letters, digits, white space, and any of the following symbols: _ . : / = + - @.

UtteranceData

Provides information about a single utterance that was made to your bot.

UtteranceList

Provides a list of utterances that have been made to a specific version of your bot. The list contains a maximum of 100 utterances.

Enums

ChannelStatus

When writing a match expression against ChannelStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ChannelType

When writing a match expression against ChannelType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ContentType

When writing a match expression against ContentType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Destination

When writing a match expression against Destination, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExportStatus

When writing a match expression against ExportStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExportType

When writing a match expression against ExportType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FulfillmentActivityType

When writing a match expression against FulfillmentActivityType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ImportStatus

When writing a match expression against ImportStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Locale

When writing a match expression against Locale, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LogType

When writing a match expression against LogType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MergeStrategy

When writing a match expression against MergeStrategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MigrationAlertType

When writing a match expression against MigrationAlertType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MigrationSortAttribute

When writing a match expression against MigrationSortAttribute, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MigrationStatus

When writing a match expression against MigrationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

MigrationStrategy

When writing a match expression against MigrationStrategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ObfuscationSetting

When writing a match expression against ObfuscationSetting, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ProcessBehavior

When writing a match expression against ProcessBehavior, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ReferenceType

When writing a match expression against ReferenceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResourceType

When writing a match expression against ResourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SlotConstraint

When writing a match expression against SlotConstraint, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SlotValueSelectionStrategy

When writing a match expression against SlotValueSelectionStrategy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SortOrder

When writing a match expression against SortOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Status

When writing a match expression against Status, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StatusType

When writing a match expression against StatusType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.