Module types

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that Amazon EMR can respond with.

Structs

Application

With Amazon EMR release version 4.0 and later, the only accepted parameter is the application name. To pass arguments to applications, you use configuration classifications specified using configuration JSON objects. For more information, see Configuring Applications.

With earlier Amazon EMR releases, the application is any Amazon or third-party software that you can add to the cluster. This structure contains a list of strings that indicates the software to use with the cluster and accepts a user argument list. Amazon EMR accepts and forwards the argument list to the corresponding installation script as bootstrap action argument.

AutoScalingPolicy

An automatic scaling policy for a core instance group or task instance group in an Amazon EMR cluster. An automatic scaling policy defines how an instance group dynamically adds and terminates Amazon EC2 instances in response to the value of a CloudWatch metric. See PutAutoScalingPolicy.

AutoScalingPolicyDescription

An automatic scaling policy for a core instance group or task instance group in an Amazon EMR cluster. The automatic scaling policy defines how an instance group dynamically adds and terminates Amazon EC2 instances in response to the value of a CloudWatch metric. See PutAutoScalingPolicy.

AutoScalingPolicyStateChangeReason

The reason for an AutoScalingPolicyStatus change.

AutoScalingPolicyStatus

The status of an automatic scaling policy.

AutoTerminationPolicy

An auto-termination policy for an Amazon EMR cluster. An auto-termination policy defines the amount of idle time in seconds after which a cluster automatically terminates. For alternative cluster termination options, see Control cluster termination.

BlockPublicAccessConfiguration

A configuration for Amazon EMR block public access. When BlockPublicSecurityGroupRules is set to true, Amazon EMR prevents cluster creation if one of the cluster's security groups has a rule that allows inbound traffic from 0.0.0.0/0 or ::/0 on a port, unless the port is specified as an exception using PermittedPublicSecurityGroupRuleRanges.

BlockPublicAccessConfigurationMetadata

Properties that describe the Amazon Web Services principal that created the BlockPublicAccessConfiguration using the PutBlockPublicAccessConfiguration action as well as the date and time that the configuration was created. Each time a configuration for block public access is updated, Amazon EMR updates this metadata.

BootstrapActionConfig

Configuration of a bootstrap action.

BootstrapActionDetail

Reports the configuration of a bootstrap action in a cluster (job flow).

CancelStepsInfo

Specification of the status of a CancelSteps request. Available only in Amazon EMR version 4.8.0 and later, excluding version 5.0.0.

CloudWatchAlarmDefinition

The definition of a CloudWatch metric alarm, which determines when an automatic scaling activity is triggered. When the defined alarm conditions are satisfied, scaling activity begins.

Cluster

The detailed description of the cluster.

ClusterStateChangeReason

The reason that the cluster changed to its current state.

ClusterStatus

The detailed status of the cluster.

ClusterSummary

The summary description of the cluster.

ClusterTimeline

Represents the timeline of the cluster's lifecycle.

Command

An entity describing an executable that runs on a cluster.

ComputeLimits

The Amazon EC2 unit limits for a managed scaling policy. The managed scaling activity of a cluster can not be above or below these limits. The limit only applies to the core and task nodes. The master node cannot be scaled after initial configuration.

Configuration

Amazon EMR releases 4.x or later.

An optional configuration specification to be used when provisioning cluster instances, which can include configurations for applications and software bundled with Amazon EMR. A configuration consists of a classification, properties, and optional nested configurations. A classification refers to an application-specific configuration file. Properties are the settings you want to change in that file. For more information, see Configuring Applications.

EbsBlockDevice

Configuration of requested EBS block device associated with the instance group.

EbsBlockDeviceConfig

Configuration of requested EBS block device associated with the instance group with count of volumes that are associated to every instance.

EbsConfiguration

The Amazon EBS configuration of a cluster instance.

EbsVolume

EBS block device that's attached to an Amazon EC2 instance.

Ec2InstanceAttributes

Provides information about the Amazon EC2 instances in a cluster grouped by category. For example, key name, subnet ID, IAM instance profile, and so on.

EmrContainersConfig

The EMR container configuration.

ErrorDetail

A tuple that provides information about an error that caused a cluster to terminate.

ExecutionEngineConfig

Specifies the execution engine (cluster) to run the notebook and perform the notebook execution, for example, an Amazon EMR cluster.

FailureDetails

The details of the step failure. The service attempts to detect the root cause for many common failures.

HadoopJarStepConfig

A job flow step consisting of a JAR file whose main function will be executed. The main function submits a job for Hadoop to execute and waits for the job to finish or fail.

HadoopStepConfig

A cluster step consisting of a JAR file whose main function will be executed. The main function submits a job for Hadoop to execute and waits for the job to finish or fail.

Instance

Represents an Amazon EC2 instance provisioned as part of cluster.

InstanceFleet

Describes an instance fleet, which is a group of Amazon EC2 instances that host a particular node type (master, core, or task) in an Amazon EMR cluster. Instance fleets can consist of a mix of instance types and On-Demand and Spot Instances, which are provisioned to meet a defined target capacity.

The instance fleet configuration is available only in Amazon EMR releases 4.8.0 and later, excluding 5.0.x versions.

InstanceFleetConfig

The configuration that defines an instance fleet.

The instance fleet configuration is available only in Amazon EMR releases 4.8.0 and later, excluding 5.0.x versions.

InstanceFleetModifyConfig

Configuration parameters for an instance fleet modification request.

The instance fleet configuration is available only in Amazon EMR releases 4.8.0 and later, excluding 5.0.x versions.

InstanceFleetProvisioningSpecifications

The launch specification for On-Demand and Spot Instances in the fleet.

The instance fleet configuration is available only in Amazon EMR releases 4.8.0 and later, excluding 5.0.x versions. On-Demand and Spot instance allocation strategies are available in Amazon EMR releases 5.12.1 and later.

InstanceFleetResizingSpecifications

The resize specification for On-Demand and Spot Instances in the fleet.

InstanceFleetStateChangeReason

Provides status change reason details for the instance fleet.

The instance fleet configuration is available only in Amazon EMR releases 4.8.0 and later, excluding 5.0.x versions.

InstanceFleetStatus

The status of the instance fleet.

The instance fleet configuration is available only in Amazon EMR releases 4.8.0 and later, excluding 5.0.x versions.

InstanceFleetTimeline

Provides historical timestamps for the instance fleet, including the time of creation, the time it became ready to run jobs, and the time of termination.

The instance fleet configuration is available only in Amazon EMR releases 4.8.0 and later, excluding 5.0.x versions.

InstanceGroup

This entity represents an instance group, which is a group of instances that have common purpose. For example, CORE instance group is used for HDFS.

InstanceGroupConfig

Configuration defining a new instance group.

InstanceGroupDetail

Detailed information about an instance group.

InstanceGroupModifyConfig

Modify the size or configurations of an instance group.

InstanceGroupStateChangeReason

The status change reason details for the instance group.

InstanceGroupStatus

The details of the instance group status.

InstanceGroupTimeline

The timeline of the instance group lifecycle.

InstanceResizePolicy

Custom policy for requesting termination protection or termination of specific instances when shrinking an instance group.

InstanceStateChangeReason

The details of the status change reason for the instance.

InstanceStatus

The instance status details.

InstanceTimeline

The timeline of the instance lifecycle.

InstanceTypeConfig

An instance type configuration for each instance type in an instance fleet, which determines the Amazon EC2 instances Amazon EMR attempts to provision to fulfill On-Demand and Spot target capacities. When you use an allocation strategy, you can include a maximum of 30 instance type configurations for a fleet. For more information about how to use an allocation strategy, see Configure Instance Fleets. Without an allocation strategy, you may specify a maximum of five instance type configurations for a fleet.

The instance fleet configuration is available only in Amazon EMR releases 4.8.0 and later, excluding 5.0.x versions.

InstanceTypeSpecification

The configuration specification for each instance type in an instance fleet.

The instance fleet configuration is available only in Amazon EMR releases 4.8.0 and later, excluding 5.0.x versions.

JobFlowDetail

A description of a cluster (job flow).

JobFlowExecutionStatusDetail

Describes the status of the cluster (job flow).

JobFlowInstancesConfig

A description of the Amazon EC2 instance on which the cluster (job flow) runs. A valid JobFlowInstancesConfig must contain either InstanceGroups or InstanceFleets. They cannot be used together. You may also have MasterInstanceType, SlaveInstanceType, and InstanceCount (all three must be present), but we don't recommend this configuration.

JobFlowInstancesDetail

Specify the type of Amazon EC2 instances that the cluster (job flow) runs on.

KerberosAttributes

Attributes for Kerberos configuration when Kerberos authentication is enabled using a security configuration. For more information see Use Kerberos Authentication in the Amazon EMR Management Guide.

KeyValue

A key-value pair.

ManagedScalingPolicy

Managed scaling policy for an Amazon EMR cluster. The policy specifies the limits for resources that can be added or terminated from a cluster. The policy only applies to the core and task nodes. The master node cannot be scaled after initial configuration.

MetricDimension

A CloudWatch dimension, which is specified using a Key (known as a Name in CloudWatch), Value pair. By default, Amazon EMR uses one dimension whose Key is JobFlowID and Value is a variable representing the cluster ID, which is ${emr.clusterId}. This enables the rule to bootstrap when the cluster ID becomes available.

NotebookExecution

A notebook execution. An execution is a specific instance that an Amazon EMR Notebook is run using the StartNotebookExecution action.

NotebookExecutionSummary

Details for a notebook execution. The details include information such as the unique ID and status of the notebook execution.

NotebookS3LocationForOutput

The Amazon S3 location that stores the notebook execution input.

NotebookS3LocationFromInput

The Amazon S3 location that stores the notebook execution input.

OnDemandCapacityReservationOptions

Describes the strategy for using unused Capacity Reservations for fulfilling On-Demand capacity.

OnDemandProvisioningSpecification

The launch specification for On-Demand Instances in the instance fleet, which determines the allocation strategy.

The instance fleet configuration is available only in Amazon EMR releases 4.8.0 and later, excluding 5.0.x versions. On-Demand Instances allocation strategy is available in Amazon EMR releases 5.12.1 and later.

OnDemandResizingSpecification

The resize specification for On-Demand Instances in the instance fleet, which contains the resize timeout period.

OsRelease

The Amazon Linux release specified for a cluster in the RunJobFlow request.

OutputNotebookS3LocationForOutput

The Amazon S3 location that stores the notebook execution output.

OutputNotebookS3LocationFromInput

The Amazon S3 location that stores the notebook execution output.

PersistentAppUi

Holds persistent application user interface information. Applications installed on the Amazon EMR cluster publish user interfaces as web sites to monitor cluster activity.

PlacementGroupConfig

Placement group configuration for an Amazon EMR cluster. The configuration specifies the placement strategy that can be applied to instance roles during cluster creation.

To use this configuration, consider attaching managed policy AmazonElasticMapReducePlacementGroupPolicy to the Amazon EMR role.

PlacementType

The Amazon EC2 Availability Zone configuration of the cluster (job flow).

PortRange

A list of port ranges that are permitted to allow inbound traffic from all public IP addresses. To specify a single port, use the same value for MinRange and MaxRange.

ReleaseLabelFilter

The release label filters by application or version prefix.

ScalingAction

The type of adjustment the automatic scaling activity makes when triggered, and the periodicity of the adjustment.

ScalingConstraints

The upper and lower Amazon EC2 instance limits for an automatic scaling policy. Automatic scaling activities triggered by automatic scaling rules will not cause an instance group to grow above or below these limits.

ScalingRule

A scale-in or scale-out rule that defines scaling activity, including the CloudWatch metric alarm that triggers activity, how Amazon EC2 instances are added or removed, and the periodicity of adjustments. The automatic scaling policy for an instance group can comprise one or more automatic scaling rules.

ScalingTrigger

The conditions that trigger an automatic scaling activity.

ScriptBootstrapActionConfig

Configuration of the script to run during a bootstrap action.

SecurityConfigurationSummary

The creation date and time, and name, of a security configuration.

SessionMappingDetail

Details for an Amazon EMR Studio session mapping including creation time, user or group ID, Studio ID, and so on.

SessionMappingSummary

Details for an Amazon EMR Studio session mapping. The details do not include the time the session mapping was last modified.

ShrinkPolicy

Policy for customizing shrink operations. Allows configuration of decommissioning timeout and targeted instance shrinking.

SimpleScalingPolicyConfiguration

An automatic scaling configuration, which describes how the policy adds or removes instances, the cooldown period, and the number of Amazon EC2 instances that will be added each time the CloudWatch metric alarm condition is satisfied.

SimplifiedApplication

The returned release label application names or versions.

SpotProvisioningSpecification

The launch specification for Spot Instances in the instance fleet, which determines the defined duration, provisioning timeout behavior, and allocation strategy.

The instance fleet configuration is available only in Amazon EMR releases 4.8.0 and later, excluding 5.0.x versions. Spot Instance allocation strategy is available in Amazon EMR releases 5.12.1 and later.

Spot Instances with a defined duration (also known as Spot blocks) are no longer available to new customers from July 1, 2021. For customers who have previously used the feature, we will continue to support Spot Instances with a defined duration until December 31, 2022.

SpotResizingSpecification

The resize specification for Spot Instances in the instance fleet, which contains the resize timeout period.

Step

This represents a step in a cluster.

StepConfig

Specification for a cluster (job flow) step.

StepDetail

Combines the execution state and configuration of a step.

StepExecutionStatusDetail

The execution state of a step.

StepStateChangeReason

The details of the step state change reason.

StepStatus

The execution status details of the cluster step.

StepSummary

The summary of the cluster step.

StepTimeline

The timeline of the cluster step lifecycle.

Studio

Details for an Amazon EMR Studio including ID, creation time, name, and so on.

StudioSummary

Details for an Amazon EMR Studio, including ID, Name, VPC, and Description. To fetch additional details such as subnets, IAM roles, security groups, and tags for the Studio, use the DescribeStudio API.

SupportedInstanceType

An instance type that the specified Amazon EMR release supports.

SupportedProductConfig

The list of supported product configurations that allow user-supplied arguments. Amazon EMR accepts these arguments and forwards them to the corresponding installation script as bootstrap action arguments.

Tag

A key-value pair containing user-defined metadata that you can associate with an Amazon EMR resource. Tags make it easier to associate clusters in various ways, such as grouping clusters to track your Amazon EMR resource allocation costs. For more information, see Tag Clusters.

UsernamePassword

The username and password that you use to connect to cluster endpoints.

VolumeSpecification

EBS volume specifications such as volume type, IOPS, size (GiB) and throughput (MiB/s) that are requested for the EBS volume attached to an Amazon EC2 instance in the cluster.

Enums

ActionOnFailure

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

AdjustmentType

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

AuthMode

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

AutoScalingPolicyState

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

AutoScalingPolicyStateChangeReasonCode

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

CancelStepsRequestStatus

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

ClusterState

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

ClusterStateChangeReasonCode

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

ComparisonOperator

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

ComputeLimitsUnitType

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

Credentials

The credentials that you can use to connect to cluster endpoints. Credentials consist of a username and a password.

ExecutionEngineType

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

IdcUserAssignment

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

IdentityType

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

InstanceCollectionType

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

InstanceFleetState

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

InstanceFleetStateChangeReasonCode

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

InstanceFleetType

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

InstanceGroupState

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

InstanceGroupStateChangeReasonCode

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

InstanceGroupType

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

InstanceRoleType

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

InstanceState

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

InstanceStateChangeReasonCode

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

JobFlowExecutionState

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

MarketType

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

NotebookExecutionStatus

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

OnClusterAppUiType

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

OnDemandCapacityReservationPreference

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

OnDemandCapacityReservationUsageStrategy

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

OnDemandProvisioningAllocationStrategy

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

OutputNotebookFormat

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

PersistentAppUiType

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

PlacementGroupStrategy

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

ProfilerType

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

ReconfigurationType

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

RepoUpgradeOnBoot

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

ScaleDownBehavior

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

ScalingStrategy

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

SpotProvisioningAllocationStrategy

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

SpotProvisioningTimeoutAction

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

Statistic

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

StepCancellationOption

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

StepExecutionState

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

StepState

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

StepStateChangeReasonCode

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

Unit

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