Module aws_sdk_gamelift::types

Data structures used by operation inputs/outputs.

Modules

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

Structs

• Alias

  Properties that describe an alias resource.

• AnywhereConfiguration

  Amazon GameLift configuration options for your Anywhere fleets.

• AttributeValue

  Values for use in player attribute key-value pairs. This object lets you specify an attribute value using any of the valid data types: string, number, string array, or data map. Each AttributeValue object can use only one of the available properties.

• AwsCredentials

  Amazon Web Services account security credentials that allow interactions with Amazon GameLift resources. The credentials are temporary and valid for a limited time span. You can request fresh credentials at any time.

• Build

  Properties describing a custom game build.

• CertificateConfiguration

  This data type has been expanded to use with the Amazon GameLift containers feature, which is currently in public preview.

• ClaimFilterOption

  This data type is used with the Amazon GameLift FleetIQ and game server groups.

• Compute

  This data type has been expanded to use with the Amazon GameLift containers feature, which is currently in public preview.

• ConnectionPortRange

  This operation has been expanded to use with the Amazon GameLift containers feature, which is currently in public preview.

• ContainerAttributes

  This data type is used with the Amazon GameLift containers feature, which is currently in public preview.

• ContainerDefinition

  This data type is used with the Amazon GameLift containers feature, which is currently in public preview.

• ContainerDefinitionInput

  This data type is used with the Amazon GameLift containers feature, which is currently in public preview.

• ContainerDependency

  This data type is used with the Amazon GameLift containers feature, which is currently in public preview.

• ContainerEnvironment

  This data type is used with the Amazon GameLift containers feature, which is currently in public preview.

• ContainerGroupDefinition

  This data type is used with the Amazon GameLift containers feature, which is currently in public preview.

• ContainerGroupDefinitionProperty

  This data type is used with the Amazon GameLift containers feature, which is currently in public preview.

• ContainerGroupsAttributes

  This data type is used with the Amazon GameLift containers feature, which is currently in public preview.

• ContainerGroupsConfiguration

  This data type is used with the Amazon GameLift containers feature, which is currently in public preview.

• ContainerGroupsPerInstance

  This data type is used with the Amazon GameLift containers feature, which is currently in public preview.

• ContainerHealthCheck

  Instructions on when and how to check the health of a container in a container fleet. When health check properties are set in a container definition, they override any Docker health checks in the container image. For more information on container health checks, see HealthCheck command in the Amazon Elastic Container Service API.

• ContainerMemoryLimits

  Specifies how much memory is available to a container. You can't change this value after you create this object.

• ContainerPortConfiguration

  Defines ranges of ports that server processes can connect to.

• ContainerPortMapping

  This data type is used with the Amazon GameLift containers feature, which is currently in public preview.

• ContainerPortRange

  This data type is used with the Amazon GameLift containers feature, which is currently in public preview.

• DesiredPlayerSession

  Player information for use when creating player sessions using a game session placement request.

• Ec2InstanceCounts

  Resource capacity settings. Fleet capacity is measured in Amazon EC2 instances. Pending and terminating counts are non-zero when the fleet capacity is adjusting to a scaling event or if access to resources is temporarily affected.

• Ec2InstanceLimit

  The Amazon GameLift service limits for an Amazon EC2 instance type and current utilization. Amazon GameLift allows Amazon Web Services accounts a maximum number of instances, per instance type, per Amazon Web Services Region or location, for use with Amazon GameLift. You can request an limit increase for your account by using the Service limits page in the Amazon GameLift console.

• Event

  Log entry describing an event that involves Amazon GameLift resources (such as a fleet). In addition to tracking activity, event codes and messages can provide additional information for troubleshooting and debugging problems.

• FilterConfiguration

  A list of fleet locations where a game session queue can place new game sessions. You can use a filter to temporarily turn off placements for specific locations. For queues that have multi-location fleets, you can use a filter configuration allow placement with some, but not all of these locations.

• FleetAttributes

  This operation has been expanded to use with the Amazon GameLift containers feature, which is currently in public preview.

• FleetCapacity

  Current resource capacity settings for managed EC2 fleets and container fleets. For multi-location fleets, location values might refer to a fleet's remote location or its home Region.

• FleetUtilization

  Current resource utilization statistics in a specified fleet or location. The location value might refer to a fleet's remote location or its home region.

• GameProperty

  This key-value pair can store custom data about a game session. For example, you might use a GameProperty to track a game session's map, level of difficulty, or remaining time. The difficulty level could be specified like this: {"Key": "difficulty", "Value":"Novice"}.

• GameServer

  This data type is used with the Amazon GameLift FleetIQ and game server groups.

• GameServerGroup

  This data type is used with the Amazon GameLift FleetIQ and game server groups.

• GameServerGroupAutoScalingPolicy

  This data type is used with the Amazon GameLift FleetIQ and game server groups.

• GameServerInstance

  This data type is used with the Amazon GameLift FleetIQ and game server groups.

• GameSession

  Properties describing a game session.

• GameSessionConnectionInfo

  Connection information for a new game session that is created in response to a start matchmaking request. Once a match is made, the FlexMatch engine creates a new game session for it. This information, including the game session endpoint and player sessions for each player in the original matchmaking request, is added to the matchmaking ticket.

• GameSessionDetail

  A game session's properties plus the protection policy currently in force.

• GameSessionPlacement

  Represents a potential game session placement, including the full details of the original placement request and the current status.

• GameSessionQueue

  Configuration for a game session placement mechanism that processes requests for new game sessions. A queue can be used on its own or as part of a matchmaking solution.

• GameSessionQueueDestination

  A fleet or alias designated in a game session queue. Queues fulfill requests for new game sessions by placing a new game session on any of the queue's destinations.

• Instance

  Represents a virtual computing instance that runs game server processes and hosts game sessions. In Amazon GameLift, one or more instances make up a managed EC2 fleet.

• InstanceAccess

  Information and credentials that you can use to remotely connect to an instance in an EC2 managed fleet. This data type is returned in response to a call to GetInstanceAccess.

• InstanceCredentials

  A set of credentials that allow remote access to an instance in an EC2 managed fleet. These credentials are returned in response to a call to GetInstanceAccess, which requests access for instances that are running game servers with the Amazon GameLift server SDK version 4.x or earlier.

• InstanceDefinition

  This data type is used with the Amazon GameLift FleetIQ and game server groups.

• IpPermission

  A range of IP addresses and port settings that allow inbound traffic to connect to processes on an instance in a fleet. Processes are assigned an IP address/port number combination, which must fall into the fleet's allowed ranges. For container fleets, the port settings must use the same port numbers as the fleet's connection ports.

• LaunchTemplateSpecification

  This data type is used with the Amazon GameLift FleetIQ and game server groups.

• LocationAttributes

  Details about a location in a multi-location fleet.

• LocationConfiguration

  This data type has been expanded to use with the Amazon GameLift containers feature, which is currently in public preview.

• LocationModel

  Properties of a custom location for use in an Amazon GameLift Anywhere fleet. This data type is returned in response to a call to https://docs.aws.amazon.com/gamelift/latest/apireference/API_CreateLocation.html.

• LocationState

  A fleet location and its life-cycle state. A location state object might be used to describe a fleet's remote location or home Region. Life-cycle state tracks the progress of launching the first instance in a new location and preparing it for game hosting, and then removing all instances and deleting the location from the fleet.

• MatchedPlayerSession

  Represents a new player session that is created as a result of a successful FlexMatch match. A successful match automatically creates new player sessions for every player ID in the original matchmaking request.

• MatchmakingConfiguration

  Guidelines for use with FlexMatch to match players into games. All matchmaking requests must specify a matchmaking configuration.

• MatchmakingRuleSet

  Set of rule statements, used with FlexMatch, that determine how to build your player matches. Each rule set describes a type of group to be created and defines the parameters for acceptable player matches.

• MatchmakingTicket

  Ticket generated to track the progress of a matchmaking request. Each ticket is uniquely identified by a ticket ID, supplied by the requester, when creating a matchmaking request.

• PlacedPlayerSession

  Information about a player session. This object contains only the player ID and player session ID. To retrieve full details on a player session, call DescribePlayerSessions with the player session ID.

• Player

  Represents a player in matchmaking. When starting a matchmaking request, a player has a player ID, attributes, and may have latency data. Team information is added after a match has been successfully completed.

• PlayerLatency

  Regional latency information for a player, used when requesting a new game session. This value indicates the amount of time lag that exists when the player is connected to a fleet in the specified Region. The relative difference between a player's latency values for multiple Regions are used to determine which fleets are best suited to place a new game session for the player.

• PlayerLatencyPolicy

  Sets a latency cap for individual players when placing a game session. With a latency policy in force, a game session cannot be placed in a fleet location where a player reports latency higher than the cap. Latency policies are used only with placement request that provide player latency information. Player latency policies can be stacked to gradually relax latency requirements over time.

• PlayerSession

  Represents a player session. Player sessions are created either for a specific game session, or as part of a game session placement or matchmaking request. A player session can represents a reserved player slot in a game session (when status is RESERVED) or actual player activity in a game session (when status is ACTIVE). A player session object, including player data, is automatically passed to a game session when the player connects to the game session and is validated. After the game session ends, player sessions information is retained for 30 days and then removed.

• PriorityConfiguration

  Custom prioritization settings for use by a game session queue when placing new game sessions with available game servers. When defined, this configuration replaces the default FleetIQ prioritization process, which is as follows:

• ReplicaContainerGroupCounts

  This data type is used with the Amazon GameLift containers feature, which is currently in public preview.

• ResourceCreationLimitPolicy

  A policy that puts limits on the number of game sessions that a player can create within a specified span of time. With this policy, you can control players' ability to consume available resources.

• RoutingStrategy

  The routing configuration for a fleet alias.

• RuntimeConfiguration

  This data type has been expanded to use with the Amazon GameLift containers feature, which is currently in public preview.

• S3Location

  The location in Amazon S3 where build or script files are stored for access by Amazon GameLift.

• ScalingPolicy

  Rule that controls how a fleet is scaled. Scaling policies are uniquely identified by the combination of name and fleet ID.

• Script

  Properties describing a Realtime script.

• ServerProcess

  A set of instructions for launching server processes on fleet computes. Server processes run either an executable in a custom game build or a Realtime Servers script. Server process configurations are part of a fleet's runtime configuration.

• Tag

  A label that you can assign to a Amazon GameLift resource.

• TargetConfiguration

  Settings for a target-based scaling policy. A target-based policy tracks a particular fleet metric specifies a target value for the metric. As player usage changes, the policy triggers Amazon GameLift to adjust capacity so that the metric returns to the target value. The target configuration specifies settings as needed for the target based policy, including the target value.

• TargetTrackingConfiguration

  This data type is used with the Amazon GameLift FleetIQ and game server groups.

• VpcPeeringAuthorization

  Represents an authorization for a VPC peering connection between the VPC for an Amazon GameLift fleet and another VPC on an account you have access to. This authorization must exist and be valid for the peering connection to be established. Authorizations are valid for 24 hours after they are issued.

• VpcPeeringConnection

  Represents a peering connection between a VPC on one of your Amazon Web Services accounts and the VPC for your Amazon GameLift fleets. This record may be for an active peering connection or a pending connection that has not yet been established.

• VpcPeeringConnectionStatus

  Represents status information for a VPC peering connection. Status codes and messages are provided from EC2 (see VpcPeeringConnectionStateReason). Connection status information is also communicated as a fleet event.

Enums

• AcceptanceType
  When writing a match expression against AcceptanceType, 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.
• BackfillMode
  When writing a match expression against BackfillMode, 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.
• BalancingStrategy
  When writing a match expression against BalancingStrategy, 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.
• BuildStatus
  When writing a match expression against BuildStatus, 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.
• CertificateType
  When writing a match expression against CertificateType, 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.
• ComparisonOperatorType
  When writing a match expression against ComparisonOperatorType, 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.
• ComputeStatus
  When writing a match expression against ComputeStatus, 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.
• ComputeType
  When writing a match expression against ComputeType, 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.
• ContainerDependencyCondition
  When writing a match expression against ContainerDependencyCondition, 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.
• ContainerGroupDefinitionStatus
  When writing a match expression against ContainerGroupDefinitionStatus, 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.
• ContainerOperatingSystem
  When writing a match expression against ContainerOperatingSystem, 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.
• ContainerSchedulingStrategy
  When writing a match expression against ContainerSchedulingStrategy, 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.
• Ec2InstanceType
  When writing a match expression against Ec2InstanceType, 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.
• EventCode
  When writing a match expression against EventCode, 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.
• FilterInstanceStatus
  When writing a match expression against FilterInstanceStatus, 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.
• FleetAction
  When writing a match expression against FleetAction, 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.
• FleetStatus
  When writing a match expression against FleetStatus, 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.
• FleetType
  When writing a match expression against FleetType, 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.
• FlexMatchMode
  When writing a match expression against FlexMatchMode, 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.
• GameServerClaimStatus
  When writing a match expression against GameServerClaimStatus, 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.
• GameServerGroupAction
  When writing a match expression against GameServerGroupAction, 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.
• GameServerGroupDeleteOption
  When writing a match expression against GameServerGroupDeleteOption, 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.
• GameServerGroupInstanceType
  When writing a match expression against GameServerGroupInstanceType, 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.
• GameServerGroupStatus
  When writing a match expression against GameServerGroupStatus, 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.
• GameServerHealthCheck
  When writing a match expression against GameServerHealthCheck, 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.
• GameServerInstanceStatus
  When writing a match expression against GameServerInstanceStatus, 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.
• GameServerProtectionPolicy
  When writing a match expression against GameServerProtectionPolicy, 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.
• GameServerUtilizationStatus
  When writing a match expression against GameServerUtilizationStatus, 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.
• GameSessionPlacementState
  When writing a match expression against GameSessionPlacementState, 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.
• GameSessionStatus
  When writing a match expression against GameSessionStatus, 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.
• GameSessionStatusReason
  When writing a match expression against GameSessionStatusReason, 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.
• InstanceRoleCredentialsProvider
  When writing a match expression against InstanceRoleCredentialsProvider, 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.
• InstanceStatus
  When writing a match expression against InstanceStatus, 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.
• IpProtocol
  When writing a match expression against IpProtocol, 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.
• LocationFilter
  When writing a match expression against LocationFilter, 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.
• LocationUpdateStatus
  When writing a match expression against LocationUpdateStatus, 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.
• MatchmakingConfigurationStatus
  When writing a match expression against MatchmakingConfigurationStatus, 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.
• MetricName
  When writing a match expression against MetricName, 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.
• OperatingSystem
  When writing a match expression against OperatingSystem, 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.
• PlayerSessionCreationPolicy
  When writing a match expression against PlayerSessionCreationPolicy, 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.
• PlayerSessionStatus
  When writing a match expression against PlayerSessionStatus, 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.
• PolicyType
  When writing a match expression against PolicyType, 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.
• PriorityType
  When writing a match expression against PriorityType, 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.
• ProtectionPolicy
  When writing a match expression against ProtectionPolicy, 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.
• RoutingStrategyType
  When writing a match expression against RoutingStrategyType, 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.
• ScalingAdjustmentType
  When writing a match expression against ScalingAdjustmentType, 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.
• ScalingStatusType
  When writing a match expression against ScalingStatusType, 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.