Module aws_sdk_chime::types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that Amazon Chime can respond with.

Structs

• Account

  The Amazon Chime account details. An AWS account can have multiple Amazon Chime accounts.

• AccountSettings

  Settings related to the Amazon Chime account. This includes settings that start or stop remote control of shared screens, or start or stop the dial-out option in the Amazon Chime web application. For more information about these settings, see Use the Policies Page in the Amazon Chime Administration Guide.

• Address

  A validated address.

• AlexaForBusinessMetadata

  The Alexa for Business metadata associated with an Amazon Chime user, used to integrate Alexa for Business with a device.

• AppInstance

  The details of an AppInstance, an instance of an Amazon Chime SDK messaging application.

• AppInstanceAdmin

  The details of an AppInstanceAdmin.

• AppInstanceAdminSummary

  Summary of the details of an AppInstanceAdmin.

• AppInstanceRetentionSettings

  The details of the data-retention settings for an AppInstance.

• AppInstanceStreamingConfiguration

  The details of the streaming configuration of an AppInstance.

• AppInstanceSummary

  Summary of the data for an AppInstance.

• AppInstanceUser

  The details of an AppInstanceUser.

• AppInstanceUserMembershipSummary

  Summary of the membership details of an AppInstanceUser.

• AppInstanceUserSummary

  Summary of the details of an AppInstanceUser.

• ArtifactsConfiguration

  The configuration for the artifacts.

• Attendee

  An Amazon Chime SDK meeting attendee. Includes a unique AttendeeId and JoinToken . The JoinToken allows a client to authenticate and join as the specified attendee. The JoinToken expires when the meeting ends or when DeleteAttendee is called. After that, the attendee is unable to join the meeting.

• AudioArtifactsConfiguration

  The audio artifact configuration object.

• BatchChannelMemberships

  The membership information, including member ARNs, the channel ARN, and membership types.

• BatchCreateChannelMembershipError

  A list of failed member ARNs, error codes, and error messages.

• Bot

  A resource that allows Enterprise account administrators to configure an interface to receive events from Amazon Chime.

• BusinessCallingSettings

  The Amazon Chime Business Calling settings for the administrator's AWS account. Includes any Amazon S3 buckets designated for storing call detail records.

• CandidateAddress

  A suggested address.

• Channel

  The details of a channel.

• ChannelBan

  The details of a channel ban.

• ChannelBanSummary

  Summary of the details of a ChannelBan.

• ChannelMembership

  The details of a channel member.

• ChannelMembershipForAppInstanceUserSummary

  Summary of the channel membership details of an AppInstanceUser.

• ChannelMembershipSummary

  Summary of the details of a ChannelMembership.

• ChannelMessage

  The details of a message in a channel.

• ChannelMessageSummary

  Summary of the messages in a Channel.

• ChannelModeratedByAppInstanceUserSummary

  Summary of the details of a moderated channel.

• ChannelModerator

  The details of a channel moderator.

• ChannelModeratorSummary

  Summary of the details of a ChannelModerator.

• ChannelRetentionSettings

  The details of the retention settings for a channel.

• ChannelSummary

  Summary of the details of a Channel.

• ChimeSdkMeetingConfiguration

  The configuration object of the Amazon Chime SDK meeting for a specified media capture pipeline. SourceType must be ChimeSdkMeeting.

• ContentArtifactsConfiguration

  The content artifact object.

• ConversationRetentionSettings

  The retention settings that determine how long to retain conversation messages for an Amazon Chime Enterprise account.

• CreateAttendeeError

  The list of errors returned when errors are encountered during the BatchCreateAttendee and CreateAttendee actions. This includes external user IDs, error codes, and error messages.

• CreateAttendeeRequestItem

  The Amazon Chime SDK attendee fields to create, used with the BatchCreateAttendee action.

• Credential

  The SIP credentials used to authenticate requests to your Amazon Chime Voice Connector.

• DnisEmergencyCallingConfiguration

  The Dialed Number Identification Service (DNIS) emergency calling configuration details associated with an Amazon Chime Voice Connector's emergency calling configuration.

• EmergencyCallingConfiguration

  The emergency calling configuration details associated with an Amazon Chime Voice Connector.

• EngineTranscribeMedicalSettings

  Settings specific to the Amazon Transcribe Medical engine.

• EngineTranscribeSettings

  Settings specific for Amazon Transcribe as the live transcription engine.

• EventsConfiguration

  The configuration that allows a bot to receive outgoing events. Can be either an HTTPS endpoint or a Lambda function ARN.

• GeoMatchParams

  The country and area code for a proxy phone number in a proxy phone session.

• Identity

  The details of a user.

• Invite

  Invitation object returned after emailing users to invite them to join the Amazon Chime Team account.

• LoggingConfiguration

  The logging configuration associated with an Amazon Chime Voice Connector. Specifies whether SIP message logs are enabled for sending to Amazon CloudWatch Logs.

• MediaCapturePipeline

  A media capture pipeline object consisting of an ID, source type, source ARN, a sink type, a sink ARN, and a configuration object.

• MediaPlacement

  A set of endpoints used by clients to connect to the media service group for an Amazon Chime SDK meeting.

• Meeting

  A meeting created using the Amazon Chime SDK.

• MeetingNotificationConfiguration

  The resource target configurations for receiving Amazon Chime SDK meeting and attendee event notifications. The Amazon Chime SDK supports resource targets located in the US East (N. Virginia) AWS Region (us-east-1).

• Member

  The member details, such as email address, name, member ID, and member type.

• MemberError

  The list of errors returned when a member action results in an error.

• MembershipItem

  Membership details, such as member ID and member role.

• MessagingSessionEndpoint

  The websocket endpoint used to connect to Amazon Chime SDK messaging.

• OrderedPhoneNumber

  A phone number for which an order has been placed.

• Origination

  Origination settings enable your SIP hosts to receive inbound calls using your Amazon Chime Voice Connector.

• OriginationRoute

  Origination routes define call distribution properties for your SIP hosts to receive inbound calls using your Amazon Chime Voice Connector. Limit: Ten origination routes for each Amazon Chime Voice Connector.

• Participant

  The phone number and proxy phone number for a participant in an Amazon Chime Voice Connector proxy session.

• PhoneNumber

  A phone number used for Amazon Chime Business Calling or an Amazon Chime Voice Connector.

• PhoneNumberAssociation

  The phone number associations, such as Amazon Chime account ID, Amazon Chime user ID, Amazon Chime Voice Connector ID, or Amazon Chime Voice Connector group ID.

• PhoneNumberCapabilities

  The phone number capabilities for Amazon Chime Business Calling phone numbers, such as enabled inbound and outbound calling and text messaging.

• PhoneNumberCountry

  The phone number country.

• PhoneNumberError

  If the phone number action fails for one or more of the phone numbers in the request, a list of the phone numbers is returned, along with error codes and error messages.

• PhoneNumberOrder

  The details of a phone number order created for Amazon Chime.

• Proxy

  The proxy configuration for an Amazon Chime Voice Connector.

• ProxySession

  The proxy session for an Amazon Chime Voice Connector.

• RetentionSettings

  The retention settings for an Amazon Chime Enterprise account that determine how long to retain items such as chat-room messages and chat-conversation messages.

• Room

  The Amazon Chime chat room details.

• RoomMembership

  The room membership details.

• RoomRetentionSettings

  The retention settings that determine how long to retain chat-room messages for an Amazon Chime Enterprise account.

• SelectedVideoStreams

  The video streams to capture for a specified media capture pipeline. The total number of video streams can't exceed 25.

• SigninDelegateGroup

  An Active Directory (AD) group whose members are granted permission to act as delegates.

• SipMediaApplication

  The details of the SIP media application, including name and endpoints. An AWS account can have multiple SIP media applications.

• SipMediaApplicationCall

  A Call instance for a SIP media application.

• SipMediaApplicationEndpoint

  The endpoint assigned to the SIP media application.

• SipMediaApplicationLoggingConfiguration

  Logging configuration of the SIP media application.

• SipRule

  The SIP rule details, including name, triggers, and target applications. An AWS account can have multiple SIP rules.

• SipRuleTargetApplication

  Target SIP media application and other details, such as priority and AWS Region, to be specified in the SIP rule. Only one SIP rule per AWS Region can be provided.

• SourceConfiguration

  Source configuration for a specified media capture pipeline.

• StreamingConfiguration

  The streaming configuration associated with an Amazon Chime Voice Connector. Specifies whether media streaming is enabled for sending to Amazon Kinesis, and shows the retention period for the Amazon Kinesis data, in hours.

• StreamingNotificationTarget

  The targeted recipient for a streaming configuration notification.

• Tag

  Describes a tag applied to a resource.

• TelephonySettings

  Settings that allow management of telephony permissions for an Amazon Chime user, such as inbound and outbound calling and text messaging.

• Termination

  Termination settings enable your SIP hosts to make outbound calls using your Amazon Chime Voice Connector.

• TerminationHealth

  The termination health details, including the source IP address and timestamp of the last successful SIP OPTIONS message from your SIP infrastructure.

• TranscriptionConfiguration

  The configuration for the current transcription operation. Must contain EngineTranscribeSettings or EngineTranscribeMedicalSettings.

• UpdatePhoneNumberRequestItem

  The phone number ID, product type, or calling name fields to update, used with the BatchUpdatePhoneNumber and UpdatePhoneNumber actions.

• UpdateUserRequestItem

  The user ID and user fields to update, used with the BatchUpdateUser action.

• User

  The user on the Amazon Chime account.

• UserError

  The list of errors returned when errors are encountered during the BatchSuspendUser, BatchUnsuspendUser, or BatchUpdateUser actions. This includes user IDs, error codes, and error messages.

• UserSettings

  Settings associated with an Amazon Chime user, including inbound and outbound calling and text messaging.

• VideoArtifactsConfiguration

  The video artifact configuration object.

• VoiceConnector

  The Amazon Chime Voice Connector configuration, including outbound host name and encryption settings.

• VoiceConnectorGroup

  The Amazon Chime Voice Connector group configuration, including associated Amazon Chime Voice Connectors. You can include Amazon Chime Voice Connectors from different AWS Regions in your group. This creates a fault tolerant mechanism for fallback in case of availability events.

• VoiceConnectorItem

  For Amazon Chime Voice Connector groups, the Amazon Chime Voice Connectors to which to route inbound calls. Includes priority configuration settings. Limit: 3 VoiceConnectorItems per Amazon Chime Voice Connector group.

• VoiceConnectorSettings

  The Amazon Chime Voice Connector settings. Includes any Amazon S3 buckets designated for storing call detail records.

Enums

• AccountStatus
  When writing a match expression against AccountStatus, 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.
• AccountType
  When writing a match expression against AccountType, 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.
• AppInstanceDataType
  When writing a match expression against AppInstanceDataType, 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.
• ArtifactsState
  When writing a match expression against ArtifactsState, 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.
• AudioMuxType
  When writing a match expression against AudioMuxType, 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.
• CallingNameStatus
  When writing a match expression against CallingNameStatus, 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.
• Capability
  When writing a match expression against Capability, 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.
• ChannelMembershipType
  When writing a match expression against ChannelMembershipType, 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.
• ChannelMessagePersistenceType
  When writing a match expression against ChannelMessagePersistenceType, 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.
• ChannelMessageType
  When writing a match expression against ChannelMessageType, 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.
• ChannelMode
  When writing a match expression against ChannelMode, 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.
• ChannelPrivacy
  When writing a match expression against ChannelPrivacy, 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.
• ContentMuxType
  When writing a match expression against ContentMuxType, 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.
• EmailStatus
  When writing a match expression against EmailStatus, 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.
• GeoMatchLevel
  When writing a match expression against GeoMatchLevel, 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.
• InviteStatus
  When writing a match expression against InviteStatus, 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.
• License
  When writing a match expression against License, 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.
• MediaPipelineSinkType
  When writing a match expression against MediaPipelineSinkType, 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.
• MediaPipelineSourceType
  When writing a match expression against MediaPipelineSourceType, 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.
• MediaPipelineStatus
  When writing a match expression against MediaPipelineStatus, 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.
• MemberType
  When writing a match expression against MemberType, 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.
• NotificationTarget
  When writing a match expression against NotificationTarget, 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.
• NumberSelectionBehavior
  When writing a match expression against NumberSelectionBehavior, 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.
• OrderedPhoneNumberStatus
  When writing a match expression against OrderedPhoneNumberStatus, 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.
• OriginationRouteProtocol
  When writing a match expression against OriginationRouteProtocol, 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.
• PhoneNumberAssociationName
  When writing a match expression against PhoneNumberAssociationName, 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.
• PhoneNumberOrderStatus
  When writing a match expression against PhoneNumberOrderStatus, 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.
• PhoneNumberProductType
  When writing a match expression against PhoneNumberProductType, 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.
• PhoneNumberStatus
  When writing a match expression against PhoneNumberStatus, 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.
• PhoneNumberType
  When writing a match expression against PhoneNumberType, 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.
• ProxySessionStatus
  When writing a match expression against ProxySessionStatus, 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.
• RegistrationStatus
  When writing a match expression against RegistrationStatus, 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.
• RoomMembershipRole
  When writing a match expression against RoomMembershipRole, 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.
• SipRuleTriggerType
  When writing a match expression against SipRuleTriggerType, 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.
• TranscribeContentIdentificationType
  When writing a match expression against TranscribeContentIdentificationType, 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.
• TranscribeContentRedactionType
  When writing a match expression against TranscribeContentRedactionType, 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.
• TranscribeLanguageCode
  When writing a match expression against TranscribeLanguageCode, 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.
• TranscribeMedicalContentIdentificationType
  When writing a match expression against TranscribeMedicalContentIdentificationType, 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.
• TranscribeMedicalLanguageCode
  When writing a match expression against TranscribeMedicalLanguageCode, 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.
• TranscribeMedicalRegion
  When writing a match expression against TranscribeMedicalRegion, 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.
• TranscribeMedicalSpecialty
  When writing a match expression against TranscribeMedicalSpecialty, 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.
• TranscribeMedicalType
  When writing a match expression against TranscribeMedicalType, 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.
• TranscribePartialResultsStability
  When writing a match expression against TranscribePartialResultsStability, 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.
• TranscribeRegion
  When writing a match expression against TranscribeRegion, 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.
• TranscribeVocabularyFilterMethod
  When writing a match expression against TranscribeVocabularyFilterMethod, 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.
• UserType
  When writing a match expression against UserType, 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.
• VideoMuxType
  When writing a match expression against VideoMuxType, 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.
• VoiceConnectorAwsRegion
  When writing a match expression against VoiceConnectorAwsRegion, 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.