Module types

Provides summary information for aggregated utterances. The ListAggregatedUtterances operations combines all instances of the same utterance into a single aggregated summary.

AllowedInputTypes

Specifies the allowed input types.

AnalyticsBinBySpecification

Contains the time metric, interval, and method by which to bin the analytics data.

AnalyticsBinKey

An object containing the criterion by which to bin the results and the value that defines that bin.

AnalyticsIntentFilter

Contains fields describing a condition by which to filter the intents. The expression may be understood as name operator values. For example:

IntentName CO Book – The intent name contains the string "Book."
BotVersion EQ 2 – The bot version is equal to two.

The operators that each filter supports are listed below:

BotAlias – EQ.
BotVersion – EQ.
LocaleId – EQ.
Modality – EQ.
Channel – EQ.
SessionId – EQ.
OriginatingRequestId – EQ.
IntentName – EQ, CO.
IntentEndState – EQ, CO.

AnalyticsIntentGroupByKey

Contains the category by which the intent analytics were grouped and a member of that category.

AnalyticsIntentGroupBySpecification

Contains the category by which to group the intents.

AnalyticsIntentMetric

Contains the metric and the summary statistic you want to calculate, and the order in which to sort the results, for the intents in the bot.

AnalyticsIntentMetricResult

An object containing the results for the intent metric you requested.

AnalyticsIntentNodeSummary

An object containing information about the requested path.

AnalyticsIntentResult

An object containing the results for the intent metrics you requested and the bin and/or group(s) they refer to, if applicable.

AnalyticsIntentStageFilter

Contains fields describing a condition by which to filter the intent stages. The expression may be understood as name operator values. For example:

IntentName CO Book – The intent name contains the string "Book."
BotVersion EQ 2 – The bot version is equal to two.

The operators that each filter supports are listed below:

BotAlias – EQ.
BotVersion – EQ.
LocaleId – EQ.
Modality – EQ.
Channel – EQ.
SessionId – EQ.
OriginatingRequestId – EQ.
IntentName – EQ, CO.
IntentStageName – EQ, CO.

AnalyticsIntentStageGroupByKey

Contains the category by which the intent stage analytics and the values for that category were grouped.

AnalyticsIntentStageGroupBySpecification

Contains the category by which to group the intent stages.

AnalyticsIntentStageMetric

Contains the metric and the summary statistic you want to calculate, and the order in which to sort the results, for the intent stages across the user sessions with the bot.

AnalyticsIntentStageMetricResult

An object containing the results for an intent stage metric you requested.

AnalyticsIntentStageResult

An object containing the results for the intent stage metrics you requested and the bin and/or group they refer to, if applicable.

AnalyticsPathFilter

Contains fields describing a condition by which to filter the paths. The expression may be understood as name operator values. For example:

LocaleId EQ en – The locale is "en".
BotVersion EQ 2 – The bot version is equal to two.

The operators that each filter supports are listed below:

BotAlias – EQ.
BotVersion – EQ.
LocaleId – EQ.
Modality – EQ.
Channel – EQ.

AnalyticsSessionFilter

Contains fields describing a condition by which to filter the sessions. The expression may be understood as name operator values. For example:

LocaleId EQ en – The locale is "en".
Duration GT 200 – The duration is greater than 200 seconds.

The operators that each filter supports are listed below:

BotAlias – EQ.
BotVersion – EQ.
LocaleId – EQ.
Modality – EQ.
Channel – EQ.
Duration – EQ, GT, LT.
conversationEndState – EQ, CO.
SessionId – EQ.
OriginatingRequestId – EQ.
IntentPath – EQ.

AnalyticsSessionGroupByKey

Contains the category by which the session analytics were grouped and a member of that category.

AnalyticsSessionGroupBySpecification

Contains the category by which to group the sessions.

AnalyticsSessionMetric

Contains the metric and the summary statistic you want to calculate, and the order in which to sort the results, for the user sessions with the bot.

AnalyticsSessionMetricResult

An object containing the results for a session metric you requested.

AnalyticsSessionResult

An object containing the results for the session metrics you requested and the bin and/or group(s) they refer to, if applicable.

AnalyticsUtteranceAttribute

An object that specifies the last used intent at the time of the utterance as an attribute to return.

AnalyticsUtteranceAttributeResult

An object containing the intent that the bot mapped the utterance to.

AnalyticsUtteranceFilter

Contains fields describing a condition by which to filter the utterances. The expression may be understood as name operator values. For example:

LocaleId EQ Book – The locale is the string "en".
UtteranceText CO help – The text of the utterance contains the string "help".

The operators that each filter supports are listed below:

BotAlias – EQ.
BotVersion – EQ.
LocaleId – EQ.
Modality – EQ.
Channel – EQ.
SessionId – EQ.
OriginatingRequestId – EQ.
UtteranceState – EQ.
UtteranceText – EQ, CO.

AnalyticsUtteranceGroupByKey

Contains the category by which the utterance analytics were grouped and the values for that category.

AnalyticsUtteranceGroupBySpecification

Contains the category by which to group the utterances.

AnalyticsUtteranceMetric

Contains the metric and the summary statistic you want to calculate, and the order in which to sort the results, for the utterances across the user sessions with the bot.

AnalyticsUtteranceMetricResult

An object containing the results for the utterance metric you requested.

AnalyticsUtteranceResult

An object containing the results for the utterance metrics you requested and the bin and/or group(s) they refer to, if applicable.

AssociatedTranscript

The object containing information that associates the recommended intent/slot type with a conversation.

AssociatedTranscriptFilter

Filters to search for the associated transcript.

AudioAndDtmfInputSpecification

Specifies the audio and DTMF input specification.

AudioLogDestination

The location of audio log files collected when conversation logging is enabled for a bot.

AudioLogSetting

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.

AudioSpecification

Specifies the audio input specifications.

BedrockGuardrailConfiguration

The details on the Bedrock guardrail configuration.

BedrockKnowledgeStoreConfiguration

Contains details about the configuration of a Amazon Bedrock knowledge base.

BedrockKnowledgeStoreExactResponseFields

The exact response fields given by the Bedrock knowledge store.

BedrockModelSpecification

Contains information about the Amazon Bedrock model used to interpret the prompt used in descriptive bot building.

BotAliasHistoryEvent

Provides a record of an event that affects a bot alias. For example, when the version of a bot that the alias points to changes.

BotAliasLocaleSettings

Specifies settings that are unique to a locale. For example, you can use different Lambda function depending on the bot's locale.

BotAliasReplicaSummary

Contains information about all the aliases replication statuses applicable for global resiliency.

BotAliasSummary

Summary information about bot aliases returned from the ListBotAliases operation.

BotAliasTestExecutionTarget

The target Amazon S3 location for the test set execution using a bot alias.

BotExportSpecification

Provides the identity of a the bot that was exported.

BotFilter

Filters the responses returned by the ListBots operation.

BotImportSpecification

Provides the bot parameters required for importing a bot.

BotLocaleExportSpecification

Provides the bot locale parameters required for exporting a bot locale.

BotLocaleFilter

Filters responses returned by the ListBotLocales operation.

BotLocaleHistoryEvent

Provides information about an event that occurred affecting the bot locale.

BotLocaleImportSpecification

Provides the bot locale parameters required for importing a bot locale.

BotLocaleSortBy

Specifies attributes for sorting a list of bot locales.

BotLocaleSummary

Summary information about bot locales returned by the ListBotLocales operation.

BotMember

A bot that is a member of a network of bots.

BotRecommendationResultStatistics

A statistical summary of the bot recommendation results.

BotRecommendationResults

The object representing the URL of the bot definition, the URL of the associated transcript, and a statistical summary of the bot recommendation results.

BotRecommendationSummary

A summary of the bot recommendation.

BotReplicaSummary

Contains summary information about all the replication statuses applicable for global resiliency.

BotSortBy

Specifies attributes for sorting a list of bots.

BotSummary

Summary information about a bot returned by the ListBots operation.

BotVersionLocaleDetails

The version of a bot used for a bot locale.

BotVersionReplicaSortBy

The sort category for the version replicated bots.

BotVersionReplicaSummary

Contains summary information for all the version replication statuses applicable for Global resiliency.

BotVersionSortBy

Specifies attributes for sorting a list of bot versions.

BotVersionSummary

Summary information about a bot version returned by the ListBotVersions operation.

BuildtimeSettings

Contains specifications about the Amazon Lex build time generative AI capabilities from Amazon Bedrock that you can turn on for your bot.

BuiltInIntentSortBy

Specifies attributes for sorting a list of built-in intents.

BuiltInIntentSummary

Provides summary information about a built-in intent for the ListBuiltInIntents operation.

BuiltInSlotTypeSortBy

Specifies attributes for sorting a list of built-in slot types.

BuiltInSlotTypeSummary

Provides summary information about a built-in slot type for the ListBuiltInSlotTypes operation.

Button

Describes a button to use on a response card used to gather slot values from a user.

CloudWatchLogGroupLogDestination

The Amazon CloudWatch Logs log group where the text and metadata logs are delivered. The log group must exist before you enable logging.

CodeHookSpecification

Contains information about code hooks that Amazon Lex calls during a conversation.

CompositeSlotTypeSetting

A composite slot is a combination of two or more slots that capture multiple pieces of information in a single user input.

Condition

Provides an expression that evaluates to true or false.

ConditionalBranch

A set of actions that Amazon Lex should run if the condition is matched.

ConditionalSpecification

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.

ConversationLevelIntentClassificationResultItem

The item listing the evaluation of intent level success or failure.

ConversationLevelResultDetail

The conversation level details of the conversation used in the test set.

ConversationLevelSlotResolutionResultItem

The slots used for the slot resolution in the conversation.

ConversationLevelTestResultItem

The test result evaluation item at the conversation level.

ConversationLevelTestResults

The test set results data at the conversation level.

ConversationLevelTestResultsFilterBy

The selection to filter the test set results data at the conversation level.

ConversationLogSettings

Configures conversation logging that saves audio, text, and metadata for the conversations with your users.

ConversationLogsDataSource

The data source that uses conversation logs.

ConversationLogsDataSourceFilterBy

The selected data source to filter the conversation log.

CustomPayload

A custom response string that Amazon Lex sends to your application. You define the content and structure the string.

CustomVocabularyEntryId

The unique entry identifier for the custom vocabulary items.

CustomVocabularyExportSpecification

Provides the parameters required for exporting a custom vocabulary.

CustomVocabularyImportSpecification

Provides the parameters required for importing a custom vocabulary.

CustomVocabularyItem

The unique custom vocabulary item from the custom vocabulary list.

DataPrivacy

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.

DataSourceConfiguration

Contains details about the configuration of the knowledge store used for the AMAZON.QnAIntent. You must have already created the knowledge store and indexed the documents within it.

DateRangeFilter

The object used for specifying the data range that the customer wants Amazon Lex to read through in the input transcripts.

DefaultConditionalBranch

A set of actions that Amazon Lex should run if none of the other conditions are met.

DescriptiveBotBuilderSpecification

Contains specifications for the descriptive bot building feature.

DialogAction

Defines the action that the bot executes at runtime when the conversation reaches this step.

DialogCodeHookInvocationSetting

Settings that specify the dialog code hook that is called by Amazon Lex at a step of the conversation.

DialogCodeHookSettings

Settings that determine the Lambda function that Amazon Lex uses for processing user responses.

DialogState

The current state of the conversation with the user.

DtmfSpecification

Specifies the DTMF input specifications.

ElicitationCodeHookInvocationSetting

Settings that specify the dialog code hook that is called by Amazon Lex between eliciting slot values.

EncryptionSetting

The object representing the passwords that were used to encrypt the data related to the bot recommendation, as well as the KMS key ARN used to encrypt the associated metadata.

ErrorLogSettings

Settings parameters for the error logs, whether it is enabled or disabled.

ExactResponseFields

Contains the names of the fields used for an exact response to the user.

ExecutionErrorDetails

Details about an error in an execution of a test set.

ExportFilter

Filters the response form the ListExports operation

ExportResourceSpecification

Provides information about the bot or bot locale that you want to export. You can specify the botExportSpecification or the botLocaleExportSpecification, but not both.

ExportSortBy

Provides information about sorting a list of exports.

ExportSummary

Provides summary information about an export in an export list.

ExternalSourceSetting

Provides information about the external source of the slot type's definition.

FailedCustomVocabularyItem

The unique failed custom vocabulary item from the custom vocabulary list.

FulfillmentCodeHookSettings

Determines if a Lambda function should be invoked for a specific intent.

FulfillmentStartResponseSpecification

Provides settings for a message that is sent to the user when a fulfillment Lambda function starts running.

FulfillmentUpdateResponseSpecification

Provides settings for a message that is sent periodically to the user while a fulfillment Lambda function is running.

FulfillmentUpdatesSpecification

Provides information for updating the user on the progress of fulfilling an intent.

GenerationSortBy

Specifies the attribute and method by which to sort the generation request information.

GenerationSummary

Contains information about a generation request made for the bot locale.

GenerativeAiSettings

Contains specifications about the generative AI capabilities from Amazon Bedrock that you can turn on for your bot.

GrammarSlotTypeSetting

Settings requried for a slot type based on a grammar that you provide.

GrammarSlotTypeSource

Describes the Amazon S3 bucket name and location for the grammar that is the source for the slot type.

ImageResponseCard

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.

ImportFilter

Filters the response from the ListImports operation.

ImportResourceSpecification

Provides information about the bot or bot locale that you want to import. You can specify the botImportSpecification or the botLocaleImportSpecification, but not both.

ImportSortBy

Provides information for sorting a list of imports.

ImportSummary

Provides summary information about an import in an import list.

InitialResponseSetting

Configuration setting for a response sent to the user before Amazon Lex starts eliciting slots.

InputContext

A context that must be active for an intent to be selected by Amazon Lex.

InputSessionStateSpecification

Specifications for the current state of the dialog between the user and the bot in the test set.

IntentClassificationTestResultItem

Information for an intent that is classified by the test workbench.

IntentClassificationTestResultItemCounts

The number of items in the intent classification test.

IntentClassificationTestResults

Information for the results of the intent classification test.

IntentClosingSetting

Provides a statement the Amazon Lex conveys to the user when the intent is successfully fulfilled.

IntentConfirmationSetting

Provides a prompt for making sure that the user is ready for the intent to be fulfilled.

IntentFilter

Filters the response from the ListIntents operation.

IntentLevelSlotResolutionTestResultItem

Information about intent-level slot resolution in a test result.

IntentLevelSlotResolutionTestResults

Indicates the success or failure of slots at the intent level.

IntentOverride

Override settings to configure the intent state.

IntentSortBy

Specifies attributes for sorting a list of intents.

IntentStatistics

The object that contains the statistical summary of recommended intents associated with the bot recommendation.

IntentSummary

Summary information about an intent returned by the ListIntents operation.

InvokedIntentSample

An object containing the name of an intent that was invoked.

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.

LambdaCodeHook

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

LexTranscriptFilter

The object that contains transcript filter details that are associated with a bot recommendation.

Message

The object that provides message text and its type.

MessageGroup

Provides one or more messages that Amazon Lex should send to the user.

MultipleValuesSetting

Indicates whether a slot can return multiple values.

NewCustomVocabularyItem

The new custom vocabulary item from the custom vocabulary list.

NluImprovementSpecification

Specifies whether the assisted nlu feature is turned on or off.

ObfuscationSetting

Determines whether Amazon Lex obscures slot values in conversation logs.

OpensearchConfiguration

Contains details about the configuration of the Amazon OpenSearch Service database used for the AMAZON.QnAIntent.

OutputContext

Describes a session context that is activated when an intent is fulfilled.

OverallTestResultItem

Information about the overall results for a test execution result.

OverallTestResults

Information about the overall test results.

ParentBotNetwork

A network of bots.

PathFormat

The object that contains a path format that will be applied when Amazon Lex reads the transcript file in the bucket you provide. Specify this object if you only want Lex to read a subset of files in your Amazon S3 bucket.

PlainTextMessage

Defines an ASCII text message to send to the user.

PostDialogCodeHookInvocationSpecification

Specifies next steps to run after the dialog code hook finishes.

PostFulfillmentStatusSpecification

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

Principal

The IAM principal that you allowing or denying access to an Amazon Lex action. You must provide a service or an arn, but not both in the same statement. For more information, see AWS JSON policy elements: Principal .

PromptAttemptSpecification

Specifies the settings on a prompt attempt.

PromptSpecification

Specifies a list of message groups that Amazon Lex sends to a user to elicit a response.

QInConnectAssistantConfiguration

The configuration details of the Qinconnect assistant.

QInConnectIntentConfiguration

The configuration details of the Qinconnect intent.

QnAIntentConfiguration

Details about the the configuration of the built-in Amazon.QnAIntent.

QnAKendraConfiguration

Contains details about the configuration of the Amazon Kendra index used for the AMAZON.QnAIntent.

RecommendedIntentSummary

An object that contains a summary of a recommended intent.

RelativeAggregationDuration

Specifies the time window that utterance statistics are returned for. The time window is always relative to the last time that the that utterances were aggregated. For example, if the ListAggregatedUtterances operation is called at 1600, the time window is set to 1 hour, and the last refresh time was 1530, only utterances made between 1430 and 1530 are returned.

You can choose the time window that statistics should be returned for.

Hours - You can request utterance statistics for 1, 3, 6, 12, or 24 hour time windows. Statistics are refreshed every half hour for 1 hour time windows, and hourly for the other time windows.
Days - You can request utterance statistics for 3 days. Statistics are refreshed every 6 hours.
Weeks - You can see statistics for one or two weeks. Statistics are refreshed every 12 hours for one week time windows, and once per day for two week time windows.

ResponseSpecification

Specifies a list of message groups that Amazon Lex uses to respond the user input.

RuntimeHintDetails

Provides an array of phrases that should be given preference when resolving values for a slot.

RuntimeHintValue

Provides the phrase that Amazon Lex should look for in the user's input to the bot.

RuntimeHints

You can provide Amazon Lex with hints to the phrases that a customer is likely to use for a slot. When a slot with hints is resolved, the phrases in the runtime hints are preferred in the resolution. You can provide hints for a maximum of 100 intents. You can provide a maximum of 100 slots.

Before you can use runtime hints with an existing bot, you must first rebuild the bot.

For more information, see Using runtime hints to improve recognition of slot values.

RuntimeSettings

Contains specifications about the Amazon Lex runtime generative AI capabilities from Amazon Bedrock that you can turn on for your bot.

S3BucketLogDestination

Specifies an Amazon S3 bucket for logging audio conversations

S3BucketTranscriptSource

The object representing the Amazon S3 bucket containing the transcript, as well as the associated metadata.

SampleUtterance

A sample utterance that invokes an intent or respond to a slot elicitation prompt.

SampleUtteranceGenerationSpecification

Contains specifications for the sample utterance generation feature.

SampleValue

Defines one of the values for a slot type.

SentimentAnalysisSettings

Determines whether Amazon Lex will use Amazon Comprehend to detect the sentiment of user utterances.

SessionDataSortBy

An object specifying the measure and method by which to sort the session analytics data.

SessionSpecification

An object containing information about a specific session.

SlotCaptureSetting

Settings used when Amazon Lex successfully captures a slot value from a user.

SlotDefaultValue

Specifies the default value to use when a user doesn't provide a value for a slot.

SlotDefaultValueSpecification

Defines a list of values that Amazon Lex should use as the default value for a slot.

SlotFilter

Filters the response from the ListSlots operation.

SlotPriority

Sets the priority that Amazon Lex should use when eliciting slot values from a user.

SlotResolutionImprovementSpecification

Contains specifications for the assisted slot resolution feature.

SlotResolutionSetting

Contains information about whether assisted slot resolution is turned on for the slot or not.

SlotResolutionTestResultItem

Information about the success and failure rate of slot resolution in the results of a test execution.

SlotResolutionTestResultItemCounts

Information about the counts for a slot resolution in the results of a test execution.

SlotSortBy

Specifies attributes for sorting a list of bots.

SlotSummary

Summary information about a slot, a value that the bot elicits from the user.

SlotTypeFilter

Filters the response from the ListSlotTypes operation.

SlotTypeSortBy

Specifies attributes for sorting a list of slot types.

SlotTypeStatistics

The object that contains the statistical summary of the recommended slot type associated with the bot recommendation.

SlotTypeSummary

Provides summary information about a slot type.

SlotTypeValue

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

SlotValue

The value to set in a slot.

SlotValueElicitationSetting

Specifies the elicitation setting details eliciting a slot.

SlotValueOverride

The slot values that Amazon Lex uses when it sets slot values in a dialog step.

SlotValueRegexFilter

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

SlotValueSelectionSetting

Contains settings used by Amazon Lex to select a slot value.

Specifications

Subslot specifications.

SsmlMessage

Defines a Speech Synthesis Markup Language (SSML) prompt.

StillWaitingResponseSpecification

Defines the messages that Amazon Lex sends to a user to remind them that the bot is waiting for a response.

SubSlotSetting

Specifications for the constituent sub slots and the expression for the composite slot.

SubSlotTypeComposition

Subslot type composition.

SubSlotValueElicitationSetting

Subslot elicitation settings.

DefaultValueSpecification is a list of default values for a constituent sub slot in a composite 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. This is similar to DefaultValueSpecification for slots.

PromptSpecification is the prompt that Amazon Lex uses to elicit the sub slot value from the user. This is similar to PromptSpecification for slots.

TestExecutionResultFilterBy

Contains information about the method by which to filter the results of the test execution.

TestExecutionResultItems

Contains the results of the test execution, grouped by type of results. See Test result details">Test results details for details about different types of results.

TestExecutionSortBy

Contains information about the method by which to sort the instances of test executions you have carried out.

TestExecutionSummary

Summarizes metadata about the test execution.

TestExecutionTarget

Contains information about the bot used for the test execution.

TestSetDiscrepancyErrors

Contains details about the errors in the test set discrepancy report

TestSetDiscrepancyReportBotAliasTarget

Contains information about the bot alias used for the test set discrepancy report.

TestSetDiscrepancyReportResourceTarget

Contains information about the resource used for the test set discrepancy report.

TestSetExportSpecification

Contains information about the test set that is exported.

TestSetGenerationDataSource

Contains information about the data source from which the test set is generated.

TestSetImportInputLocation

Contains information about the Amazon S3 location from which the test set is imported.

TestSetImportResourceSpecification

Contains information about the test set that is imported.

TestSetIntentDiscrepancyItem

Contains information about discrepancy in an intent information between the test set and the bot.

TestSetSlotDiscrepancyItem

Contains information about discrepancy in a slot information between the test set and the bot.

TestSetSortBy

Contains information about the methods by which to sort the test set.

TestSetStorageLocation

Contains information about the location in which the test set is stored.

TestSetSummary

Contains summary information about the test set.

TestSetTurnRecord

Contains information about a turn in a test set.

TestSetTurnResult

Contains information about the results of the analysis of a turn in the test set.

TextInputSpecification

Specifies the text input specifications.

TextLogDestination

Defines the Amazon CloudWatch Logs destination log group for conversation text logs.

TextLogSetting

Defines settings to enable text conversation logs.

TranscriptFilter

The object representing the filter that Amazon Lex will use to select the appropriate transcript.

TranscriptSourceSetting

Indicates the setting of the location where the transcript is stored.

TurnSpecification

Contains information about the messages in the turn.

UserTurnInputSpecification

Contains information about the user messages in the turn in the input.

UserTurnIntentOutput

Contains information about the intent that is output for the turn by the test execution.

UserTurnOutputSpecification

Contains results that are output for the user turn by the test execution.

UserTurnResult

Contains the results for the user turn by the test execution.

UserTurnSlotOutput

Contains information about a slot output by the test set execution.

UserTurnSpecification

Contains information about the expected and input values for the user turn.

UtteranceAggregationDuration

Provides parameters for setting the time window and duration for aggregating utterance data.

UtteranceAudioInputSpecification

Contains information about the audio for an utterance.

UtteranceBotResponse

An object that contains a response to the utterance from the bot.

UtteranceDataSortBy

An object specifying the measure and method by which to sort the utterance data.

UtteranceInputSpecification

Contains information about input of an utterance.

UtteranceLevelTestResultItem

Contains information about multiple utterances in the results of a test set execution.

UtteranceLevelTestResults

Contains information about the utterances in the results of the test set execution.

UtteranceSpecification

An object containing information about a specific utterance.

VoiceSettings

Defines settings for using an Amazon Polly voice to communicate with a user.

Valid values include:

standard
neural
long-form
generative

WaitAndContinueSpecification

Specifies the prompts that Amazon Lex uses while a bot is waiting for customer input.

Enums§

AggregatedUtterancesFilterName: When writing a match expression against AggregatedUtterancesFilterName, 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.
AggregatedUtterancesFilterOperator: When writing a match expression against AggregatedUtterancesFilterOperator, 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.
AggregatedUtterancesSortAttribute: When writing a match expression against AggregatedUtterancesSortAttribute, 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.
AnalyticsBinByName: When writing a match expression against AnalyticsBinByName, 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.
AnalyticsCommonFilterName: When writing a match expression against AnalyticsCommonFilterName, 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.
AnalyticsFilterOperator: When writing a match expression against AnalyticsFilterOperator, 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.
AnalyticsIntentField: When writing a match expression against AnalyticsIntentField, 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.
AnalyticsIntentFilterName: When writing a match expression against AnalyticsIntentFilterName, 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.
AnalyticsIntentMetricName: When writing a match expression against AnalyticsIntentMetricName, 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.
AnalyticsIntentStageField: When writing a match expression against AnalyticsIntentStageField, 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.
AnalyticsIntentStageFilterName: When writing a match expression against AnalyticsIntentStageFilterName, 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.
AnalyticsIntentStageMetricName: When writing a match expression against AnalyticsIntentStageMetricName, 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.
AnalyticsInterval: When writing a match expression against AnalyticsInterval, 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.
AnalyticsMetricStatistic: When writing a match expression against AnalyticsMetricStatistic, 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.
AnalyticsModality: When writing a match expression against AnalyticsModality, 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.
AnalyticsNodeType: When writing a match expression against AnalyticsNodeType, 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.
AnalyticsSessionField: When writing a match expression against AnalyticsSessionField, 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.
AnalyticsSessionFilterName: When writing a match expression against AnalyticsSessionFilterName, 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.
AnalyticsSessionMetricName: When writing a match expression against AnalyticsSessionMetricName, 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.
AnalyticsSessionSortByName: When writing a match expression against AnalyticsSessionSortByName, 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.
AnalyticsSortOrder: When writing a match expression against AnalyticsSortOrder, 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.
AnalyticsUtteranceAttributeName: When writing a match expression against AnalyticsUtteranceAttributeName, 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.
AnalyticsUtteranceField: When writing a match expression against AnalyticsUtteranceField, 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.
AnalyticsUtteranceFilterName: When writing a match expression against AnalyticsUtteranceFilterName, 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.
AnalyticsUtteranceMetricName: When writing a match expression against AnalyticsUtteranceMetricName, 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.
AnalyticsUtteranceSortByName: When writing a match expression against AnalyticsUtteranceSortByName, 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.
AssociatedTranscriptFilterName: When writing a match expression against AssociatedTranscriptFilterName, 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.
AudioRecognitionStrategy: When writing a match expression against AudioRecognitionStrategy, 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.
BedrockTraceStatus: When writing a match expression against BedrockTraceStatus, 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.
BotAliasReplicationStatus: When writing a match expression against BotAliasReplicationStatus, 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.
BotAliasStatus: When writing a match expression against BotAliasStatus, 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.
BotFilterName: When writing a match expression against BotFilterName, 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.
BotFilterOperator: When writing a match expression against BotFilterOperator, 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.
BotLocaleFilterName: When writing a match expression against BotLocaleFilterName, 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.
BotLocaleFilterOperator: When writing a match expression against BotLocaleFilterOperator, 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.
BotLocaleSortAttribute: When writing a match expression against BotLocaleSortAttribute, 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.
BotLocaleStatus: When writing a match expression against BotLocaleStatus, 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.
BotRecommendationStatus: When writing a match expression against BotRecommendationStatus, 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.
BotReplicaStatus: When writing a match expression against BotReplicaStatus, 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.
BotSortAttribute: When writing a match expression against BotSortAttribute, 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.
BotStatus: When writing a match expression against BotStatus, 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.
BotType: When writing a match expression against BotType, 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.
BotVersionReplicaSortAttribute: When writing a match expression against BotVersionReplicaSortAttribute, 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.
BotVersionReplicationStatus: When writing a match expression against BotVersionReplicationStatus, 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.
BotVersionSortAttribute: When writing a match expression against BotVersionSortAttribute, 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.
BuiltInIntentSortAttribute: When writing a match expression against BuiltInIntentSortAttribute, 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.
BuiltInSlotTypeSortAttribute: When writing a match expression against BuiltInSlotTypeSortAttribute, 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.
ConversationEndState: When writing a match expression against ConversationEndState, 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.
ConversationLogsInputModeFilter: When writing a match expression against ConversationLogsInputModeFilter, 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.
CustomVocabularyStatus: When writing a match expression against CustomVocabularyStatus, 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.
DialogActionType: When writing a match expression against DialogActionType, 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.
Effect: When writing a match expression against Effect, 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.
ErrorCode: When writing a match expression against ErrorCode, 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.
ExportFilterName: When writing a match expression against ExportFilterName, 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.
ExportFilterOperator: When writing a match expression against ExportFilterOperator, 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.
ExportSortAttribute: When writing a match expression against ExportSortAttribute, 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.
GenerationSortByAttribute: When writing a match expression against GenerationSortByAttribute, 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.
GenerationStatus: When writing a match expression against GenerationStatus, 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.
ImportExportFileFormat: When writing a match expression against ImportExportFileFormat, 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.
ImportFilterName: When writing a match expression against ImportFilterName, 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.
ImportFilterOperator: When writing a match expression against ImportFilterOperator, 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.
ImportResourceType: When writing a match expression against ImportResourceType, 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.
ImportSortAttribute: When writing a match expression against ImportSortAttribute, 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.
IntentFilterName: When writing a match expression against IntentFilterName, 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.
IntentFilterOperator: When writing a match expression against IntentFilterOperator, 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.
IntentSortAttribute: When writing a match expression against IntentSortAttribute, 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.
IntentState: When writing a match expression against IntentState, 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.
MessageSelectionStrategy: When writing a match expression against MessageSelectionStrategy, 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.
ObfuscationSettingType: When writing a match expression against ObfuscationSettingType, 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.
PromptAttempt: When writing a match expression against PromptAttempt, 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.
SearchOrder: When writing a match expression against SearchOrder, 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.
SlotFilterName: When writing a match expression against SlotFilterName, 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.
SlotFilterOperator: When writing a match expression against SlotFilterOperator, 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.
SlotResolutionStrategy: When writing a match expression against SlotResolutionStrategy, 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.
SlotShape: When writing a match expression against SlotShape, 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.
SlotSortAttribute: When writing a match expression against SlotSortAttribute, 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.
SlotTypeCategory: When writing a match expression against SlotTypeCategory, 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.
SlotTypeFilterName: When writing a match expression against SlotTypeFilterName, 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.
SlotTypeFilterOperator: When writing a match expression against SlotTypeFilterOperator, 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.
SlotTypeSortAttribute: When writing a match expression against SlotTypeSortAttribute, 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.
SlotValueResolutionStrategy: When writing a match expression against SlotValueResolutionStrategy, 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.
TestExecutionApiMode: When writing a match expression against TestExecutionApiMode, 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.
TestExecutionModality: When writing a match expression against TestExecutionModality, 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.
TestExecutionSortAttribute: When writing a match expression against TestExecutionSortAttribute, 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.
TestExecutionStatus: When writing a match expression against TestExecutionStatus, 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.
TestResultMatchStatus: When writing a match expression against TestResultMatchStatus, 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.
TestResultTypeFilter: When writing a match expression against TestResultTypeFilter, 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.
TestSetDiscrepancyReportStatus: When writing a match expression against TestSetDiscrepancyReportStatus, 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.
TestSetGenerationStatus: When writing a match expression against TestSetGenerationStatus, 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.
TestSetModality: When writing a match expression against TestSetModality, 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.
TestSetSortAttribute: When writing a match expression against TestSetSortAttribute, 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.
TestSetStatus: When writing a match expression against TestSetStatus, 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.
TimeDimension: When writing a match expression against TimeDimension, 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.
TranscriptFormat: When writing a match expression against TranscriptFormat, 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.
UtteranceContentType: When writing a match expression against UtteranceContentType, 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.
VoiceEngine: When writing a match expression against VoiceEngine, 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.

Module types

Module types Copy item path

Modules§

Structs§

Enums§

Module types