Module aws_sdk_lexmodelsv2::types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that Amazon Lex Model Building V2 can respond with.

Structs

• AdvancedRecognitionSetting

  Provides settings that enable advanced recognition settings for slot values.

• AggregatedUtterancesFilter

  Filters responses returned by the ListAggregatedUtterances operation.

• AggregatedUtterancesSortBy

  Specifies attributes for sorting a list of utterances.

• AggregatedUtterancesSummary

  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.

• 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.

• 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.

• BotAliasSummary

  Summary information about bot aliases returned from the ListBotAliases operation.

• 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.

• 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.

• BotVersionSortBy

  Specifies attributes for sorting a list of bot versions.

• BotVersionSummary

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

• 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.

• ConversationLogSettings

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

• 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.

• 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.

• 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.

• 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.

• 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.

• 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

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

• 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.

• 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.

• 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 it's 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.

• ObfuscationSetting

  Determines whether Amazon Lex obscures slot values in conversation logs.

• OutputContext

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

• 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.

• 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.

• ResponseSpecification

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

• 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.

• 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.

• 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.

• 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 for constituent sub slots of a composite 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.

• 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.

• UtteranceAggregationDuration

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

• VoiceSettings

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

• 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.
• 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.
• 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.
• 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.
• 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.
• 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.
• 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.
• 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.
• 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.
• 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.
• 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.