Module types

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that AWS Compute Optimizer can respond with.

Structs

AccountEnrollmentStatus

Describes the enrollment status of an organization's member accounts in Compute Optimizer.

AutoScalingGroupConfiguration

Describes the configuration of an EC2 Auto Scaling group.

AutoScalingGroupEstimatedMonthlySavings

An object that describes the estimated monthly savings possible by adopting Compute Optimizer’s Auto Scaling group recommendations. This is based on the Savings Plans and Reserved Instances discounts.

AutoScalingGroupRecommendation

Describes an Auto Scaling group recommendation.

AutoScalingGroupRecommendationOption

Describes a recommendation option for an Auto Scaling group.

AutoScalingGroupSavingsOpportunityAfterDiscounts

Describes the savings opportunity for Auto Scaling group recommendations after applying the Savings Plans and Reserved Instances discounts.

Savings opportunity represents the estimated monthly savings you can achieve by implementing Compute Optimizer recommendations.

ContainerConfiguration

Describes the container configurations within the tasks of your Amazon ECS service.

ContainerRecommendation

The CPU and memory recommendations for a container within the tasks of your Amazon ECS service.

CurrentPerformanceRiskRatings

Describes the performance risk ratings for a given resource type.

Resources with a high or medium rating are at risk of not meeting the performance needs of their workloads, while resources with a low rating are performing well in their workloads.

CustomizableMetricParameters

Defines the various metric parameters that can be customized, such as threshold and headroom.

DbStorageConfiguration

The configuration of the recommended RDS storage.

EbsEffectiveRecommendationPreferences

Describes the effective recommendation preferences for Amazon EBS volumes.

EbsEstimatedMonthlySavings

An object that describes the estimated monthly savings possible by adopting Compute Optimizer’s Amazon EBS volume recommendations. This includes any applicable discounts.

EbsFilter

Describes a filter that returns a more specific list of Amazon Elastic Block Store (Amazon EBS) volume recommendations. Use this filter with the GetEBSVolumeRecommendations action.

You can use LambdaFunctionRecommendationFilter with the GetLambdaFunctionRecommendations action, JobFilter with the DescribeRecommendationExportJobs action, and Filter with the GetAutoScalingGroupRecommendations and GetEC2InstanceRecommendations actions.

EbsSavingsEstimationMode

Describes the savings estimation mode used for calculating savings opportunity for Amazon EBS volumes.

EbsSavingsOpportunityAfterDiscounts

Describes the savings opportunity for Amazon EBS volume recommendations after applying specific discounts.

EbsUtilizationMetric

Describes a utilization metric of an Amazon Elastic Block Store (Amazon EBS) volume.

Compare the utilization metric data of your resource against its projected utilization metric data to determine the performance difference between your current resource and the recommended option.

EcsEffectiveRecommendationPreferences

Describes the effective recommendation preferences for Amazon ECS services.

EcsEstimatedMonthlySavings

Describes the estimated monthly savings possible for Amazon ECS services by adopting Compute Optimizer recommendations. This is based on Amazon ECS service pricing after applying Savings Plans discounts.

EcsSavingsEstimationMode

Describes the savings estimation mode used for calculating savings opportunity for Amazon ECS services.

EcsSavingsOpportunityAfterDiscounts

Describes the savings opportunity for Amazon ECS service recommendations after applying Savings Plans discounts.

Savings opportunity represents the estimated monthly savings after applying Savings Plans discounts. You can achieve this by implementing a given Compute Optimizer recommendation.

EcsServiceProjectedMetric

Describes the projected metrics of an Amazon ECS service recommendation option.

To determine the performance difference between your current Amazon ECS service and the recommended option, compare the metric data of your service against its projected metric data.

EcsServiceProjectedUtilizationMetric

Describes the projected utilization metrics of an Amazon ECS service recommendation option.

To determine the performance difference between your current Amazon ECS service and the recommended option, compare the utilization metric data of your service against its projected utilization metric data.

EcsServiceRecommendation

Describes an Amazon ECS service recommendation.

EcsServiceRecommendationFilter

Describes a filter that returns a more specific list of Amazon ECS service recommendations. Use this filter with the GetECSServiceRecommendations action.

EcsServiceRecommendationOption

Describes the recommendation options for an Amazon ECS service.

EcsServiceRecommendedOptionProjectedMetric

Describes the projected metrics of an Amazon ECS service recommendation option.

To determine the performance difference between your current Amazon ECS service and the recommended option, compare the metric data of your service against its projected metric data.

EcsServiceUtilizationMetric

Describes the utilization metric of an Amazon ECS service.

To determine the performance difference between your current Amazon ECS service and the recommended option, compare the utilization metric data of your service against its projected utilization metric data.

EffectivePreferredResource

Describes the effective preferred resources that Compute Optimizer considers as rightsizing recommendation candidates.

Compute Optimizer only supports Amazon EC2 instance types.

EffectiveRecommendationPreferences

Describes the effective recommendation preferences for a resource.

EnrollmentFilter

Describes a filter that returns a more specific list of account enrollment statuses. Use this filter with the GetEnrollmentStatusesForOrganization action.

EstimatedMonthlySavings

Describes the estimated monthly savings amount possible, based on On-Demand instance pricing, by adopting Compute Optimizer recommendations for a given resource.

For more information, see Estimated monthly savings and savings opportunities in the Compute Optimizer User Guide.

ExportDestination

Describes the destination of the recommendations export and metadata files.

ExternalMetricStatus

Describes Compute Optimizer's integration status with your chosen external metric provider. For example, Datadog.

ExternalMetricsPreference

Describes the external metrics preferences for EC2 rightsizing recommendations.

Filter

Describes a filter that returns a more specific list of recommendations. Use this filter with the GetAutoScalingGroupRecommendations and GetEC2InstanceRecommendations actions.

You can use EBSFilter with the GetEBSVolumeRecommendations action, LambdaFunctionRecommendationFilter with the GetLambdaFunctionRecommendations action, and JobFilter with the DescribeRecommendationExportJobs action.

GetRecommendationError

Describes an error experienced when getting recommendations.

For example, an error is returned if you request recommendations for an unsupported Auto Scaling group, or if you request recommendations for an instance of an unsupported instance family.

Gpu

Describes the GPU accelerators for the instance type.

GpuInfo

Describes the GPU accelerator settings for the instance type.

IdleEstimatedMonthlySavings

Describes the estimated monthly savings possible for idle resources by adopting Compute Optimizer recommendations.

IdleRecommendation

Describes an Idle resource recommendation.

IdleRecommendationError

Returns of list of resources that doesn't have idle recommendations.

IdleRecommendationFilter

Describes a filter that returns a more specific list of idle resource recommendations.

IdleSavingsOpportunity

Describes the savings opportunity for idle resource recommendations.

IdleSavingsOpportunityAfterDiscounts

Describes the savings opportunity for idle resource recommendations after applying discounts.

Savings opportunity represents the estimated monthly savings after applying discounts. You can achieve this by implementing a given Compute Optimizer recommendation.

IdleSummary

Describes the findings summary of the idle resources.

IdleUtilizationMetric

Describes the utilization metric of an idle resource.

InferredWorkloadSaving

The estimated monthly savings after you adjust the configurations of your instances running on the inferred workload types to the recommended configurations. If the inferredWorkloadTypes list contains multiple entries, then the savings are the sum of the monthly savings from instances that run the exact combination of the inferred workload types.

InstanceEstimatedMonthlySavings

An object that describes the estimated monthly savings possible by adopting Compute Optimizer’s Amazon EC2 instance recommendations. This is based on the Savings Plans and Reserved Instances pricing discounts.

InstanceRecommendation

Describes an Amazon EC2 instance recommendation.

InstanceRecommendationOption

Describes a recommendation option for an Amazon EC2 instance.

InstanceSavingsEstimationMode

Describes the savings estimation mode used for calculating savings opportunity for Amazon EC2 instances.

InstanceSavingsOpportunityAfterDiscounts

Describes the savings opportunity for instance recommendations after applying the Savings Plans and Reserved Instances discounts.

Savings opportunity after discounts represents the estimated monthly savings you can achieve by implementing Compute Optimizer recommendations.

JobFilter

Describes a filter that returns a more specific list of recommendation export jobs. Use this filter with the DescribeRecommendationExportJobs action.

You can use EBSFilter with the GetEBSVolumeRecommendations action, LambdaFunctionRecommendationFilter with the GetLambdaFunctionRecommendations action, and Filter with the GetAutoScalingGroupRecommendations and GetEC2InstanceRecommendations actions.

LambdaEffectiveRecommendationPreferences

Describes the effective recommendation preferences for Lambda functions.

LambdaEstimatedMonthlySavings

Describes the estimated monthly savings possible for Lambda functions by adopting Compute Optimizer recommendations. This is based on Lambda functions pricing after applying Savings Plans discounts.

LambdaFunctionMemoryProjectedMetric

Describes a projected utilization metric of an Lambda function recommendation option.

LambdaFunctionMemoryRecommendationOption

Describes a recommendation option for an Lambda function.

LambdaFunctionRecommendation

Describes an Lambda function recommendation.

LambdaFunctionRecommendationFilter

Describes a filter that returns a more specific list of Lambda function recommendations. Use this filter with the GetLambdaFunctionRecommendations action.

You can use EBSFilter with the GetEBSVolumeRecommendations action, JobFilter with the DescribeRecommendationExportJobs action, and Filter with the GetAutoScalingGroupRecommendations and GetEC2InstanceRecommendations actions.

LambdaFunctionUtilizationMetric

Describes a utilization metric of an Lambda function.

LambdaSavingsEstimationMode

Describes the savings estimation used for calculating savings opportunity for Lambda functions.

LambdaSavingsOpportunityAfterDiscounts

Describes the savings opportunity for Lambda functions recommendations after applying Savings Plans discounts.

Savings opportunity represents the estimated monthly savings after applying Savings Plans discounts. You can achieve this by implementing a given Compute Optimizer recommendation.

LicenseConfiguration

Describes the configuration of a license for an Amazon EC2 instance.

LicenseRecommendation

Describes a license recommendation for an EC2 instance.

LicenseRecommendationFilter

Describes a filter that returns a more specific list of license recommendations. Use this filter with the GetLicenseRecommendation action.

LicenseRecommendationOption

Describes the recommendation options for licenses.

MemorySizeConfiguration

The memory size configurations of a container.

MetricSource

The list of metric sources required to generate recommendations for commercial software licenses.

OrderBy

Describes how the recommendations are ordered.

PreferredResource

The preference to control which resource type values are considered when generating rightsizing recommendations. You can specify this preference as a combination of include and exclude lists. You must specify either an includeList or excludeList. If the preference is an empty set of resource type values, an error occurs. For more information, see Rightsizing recommendation preferences in the Compute Optimizer User Guide.

• This preference is only available for the Amazon EC2 instance and Auto Scaling group resource types.

• Compute Optimizer only supports the customization of Ec2InstanceTypes.

ProjectedMetric

Describes a projected utilization metric of a recommendation option, such as an Amazon EC2 instance. This represents the projected utilization of a recommendation option had you used that resource during the analyzed period.

Compare the utilization metric data of your resource against its projected utilization metric data to determine the performance difference between your current resource and the recommended option.

The Cpu, Memory, GPU, and GPU_MEMORY metrics are the only projected utilization metrics returned when you run the GetEC2RecommendationProjectedMetrics action. Additionally, these metrics are only returned for resources with the unified CloudWatch agent installed on them. For more information, see Enabling Memory Utilization with the CloudWatch Agent and Enabling NVIDIA GPU utilization with the CloudWatch Agent.

RdsDatabaseProjectedMetric

Describes the projected metrics of an Amazon Aurora and RDS database recommendation option.

To determine the performance difference between your current Amazon Aurora and RDS database and the recommended option, compare the metric data of your service against its projected metric data.

RdsDatabaseRecommendedOptionProjectedMetric

Describes the projected metrics of an Amazon Aurora and RDS database recommendation option.

To determine the performance difference between your current Amazon Aurora and RDS database and the recommended option, compare the metric data of your service against its projected metric data.

RdsEffectiveRecommendationPreferences

Describes the effective recommendation preferences for Amazon Aurora and RDS databases.

RdsInstanceEstimatedMonthlySavings

Describes the estimated monthly savings possible for DB instances by adopting Compute Optimizer recommendations. This is based on DB instance pricing after applying Savings Plans discounts.

RdsInstanceSavingsOpportunityAfterDiscounts

Describes the savings opportunity for DB instance recommendations after applying Savings Plans discounts.

Savings opportunity represents the estimated monthly savings after applying Savings Plans discounts. You can achieve this by implementing a given Compute Optimizer recommendation.

RdsSavingsEstimationMode

Describes the savings estimation mode used for calculating savings opportunity for DB instances.

RdsStorageEstimatedMonthlySavings

Describes the estimated monthly savings possible for DB instance storage by adopting Compute Optimizer recommendations. This is based on DB instance pricing after applying Savings Plans discounts.

RdsStorageSavingsOpportunityAfterDiscounts

Describes the savings opportunity for Amazon RDS storage recommendations after applying Savings Plans discounts.

Savings opportunity represents the estimated monthly savings after applying Savings Plans discounts. You can achieve this by implementing a given Compute Optimizer recommendation.

RdsdbInstanceRecommendationOption

Describes the recommendation options for a DB instance.

RdsdbRecommendation

Describes an Amazon Aurora and RDS database recommendation.

RdsdbRecommendationFilter

Describes a filter that returns a more specific list of DB instance recommendations. Use this filter with the GetECSServiceRecommendations action.

RdsdbStorageRecommendationOption

Describes the recommendation options for DB storage.

RdsdbUtilizationMetric

Describes the utilization metric of an Amazon Aurora and RDS database.

To determine the performance difference between your current DB instance and the recommended option, compare the utilization metric data of your service against its projected utilization metric data.

ReasonCodeSummary

A summary of a finding reason code.

RecommendationExportJob

Describes a recommendation export job.

Use the DescribeRecommendationExportJobs action to view your recommendation export jobs.

Use the ExportAutoScalingGroupRecommendations or ExportEC2InstanceRecommendations actions to request an export of your recommendations.

RecommendationPreferences

Describes the recommendation preferences to return in the response of a GetAutoScalingGroupRecommendations, GetEC2InstanceRecommendations, GetEC2RecommendationProjectedMetrics, GetRDSDatabaseRecommendations, and GetRDSDatabaseRecommendationProjectedMetrics request.

RecommendationPreferencesDetail

Describes a recommendation preference.

RecommendationSource

Describes the source of a recommendation, such as an Amazon EC2 instance or Auto Scaling group.

RecommendationSummary

A summary of a recommendation.

RecommendedOptionProjectedMetric

Describes a projected utilization metric of a recommendation option.

The Cpu and Memory metrics are the only projected utilization metrics returned when you run the GetEC2RecommendationProjectedMetrics action. Additionally, the Memory metric is returned only for resources that have the unified CloudWatch agent installed on them. For more information, see Enabling Memory Utilization with the CloudWatch Agent.

S3Destination

Describes the destination Amazon Simple Storage Service (Amazon S3) bucket name and object keys of a recommendations export file, and its associated metadata file.

S3DestinationConfig

Describes the destination Amazon Simple Storage Service (Amazon S3) bucket name and key prefix for a recommendations export job.

You must create the destination Amazon S3 bucket for your recommendations export before you create the export job. Compute Optimizer does not create the S3 bucket for you. After you create the S3 bucket, ensure that it has the required permission policy to allow Compute Optimizer to write the export file to it. If you plan to specify an object prefix when you create the export job, you must include the object prefix in the policy that you add to the S3 bucket. For more information, see Amazon S3 Bucket Policy for Compute Optimizer in the Compute Optimizer User Guide.

SavingsOpportunity

Describes the savings opportunity for recommendations of a given resource type or for the recommendation option of an individual resource.

Savings opportunity represents the estimated monthly savings you can achieve by implementing a given Compute Optimizer recommendation.

Savings opportunity data requires that you opt in to Cost Explorer, as well as activate Receive Amazon EC2 resource recommendations in the Cost Explorer preferences page. That creates a connection between Cost Explorer and Compute Optimizer. With this connection, Cost Explorer generates savings estimates considering the price of existing resources, the price of recommended resources, and historical usage data. Estimated monthly savings reflects the projected dollar savings associated with each of the recommendations generated. For more information, see Enabling Cost Explorer and Optimizing your cost with Rightsizing Recommendations in the Cost Management User Guide.

Scope

Describes the scope of a recommendation preference.

Recommendation preferences can be created at the organization level (for management accounts of an organization only), account level, and resource level. For more information, see Activating enhanced infrastructure metrics in the Compute Optimizer User Guide.

You cannot create recommendation preferences for Auto Scaling groups at the organization and account levels. You can create recommendation preferences for Auto Scaling groups only at the resource level by specifying a scope name of ResourceArn and a scope value of the Auto Scaling group Amazon Resource Name (ARN). This will configure the preference for all instances that are part of the specified Auto Scaling group. You also cannot create recommendation preferences at the resource level for instances that are part of an Auto Scaling group. You can create recommendation preferences at the resource level only for standalone instances.

ServiceConfiguration

The Amazon ECS service configurations used for recommendations.

Summary

The summary of a recommendation.

Tag

A list of tag key and value pairs that you define.

UtilizationMetric

Describes a utilization metric of a resource, such as an Amazon EC2 instance.

Compare the utilization metric data of your resource against its projected utilization metric data to determine the performance difference between your current resource and the recommended option.

UtilizationPreference

The preference to control the resource’s CPU utilization threshold, CPU utilization headroom, and memory utilization headroom.

This preference is only available for the Amazon EC2 instance resource type.

VolumeConfiguration

Describes the configuration of an Amazon Elastic Block Store (Amazon EBS) volume.

VolumeRecommendation

Describes an Amazon Elastic Block Store (Amazon EBS) volume recommendation.

VolumeRecommendationOption

Describes a recommendation option for an Amazon Elastic Block Store (Amazon EBS) instance.

Enums

AllocationStrategy

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

AsgType

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

AutoScalingConfiguration

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

CpuVendorArchitecture

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

Currency

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

CurrentPerformanceRisk

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

CustomizableMetricHeadroom

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

CustomizableMetricName

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

CustomizableMetricThreshold

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

Dimension

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

EbsFilterName

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

EbsFinding

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

EbsMetricName

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

EbsSavingsEstimationModeSource

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

EcsSavingsEstimationModeSource

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

EcsServiceLaunchType

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

EcsServiceMetricName

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

EcsServiceMetricStatistic

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

EcsServiceRecommendationFilterName

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

EcsServiceRecommendationFinding

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

EcsServiceRecommendationFindingReasonCode

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

EnhancedInfrastructureMetrics

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

EnrollmentFilterName

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

ExportableAutoScalingGroupField

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

ExportableEcsServiceField

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

ExportableIdleField

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

ExportableInstanceField

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

ExportableLambdaFunctionField

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

ExportableLicenseField

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

ExportableRdsdbField

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

ExportableVolumeField

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

ExternalMetricStatusCode

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

ExternalMetricsSource

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

FileFormat

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

FilterName

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

Finding

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

FindingReasonCode

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

Idle

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

IdleFinding

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

IdleMetricName

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

IdleRecommendationFilterName

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

IdleRecommendationResourceType

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

InferredWorkloadType

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

InferredWorkloadTypesPreference

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

InstanceIdle

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

InstanceRecommendationFindingReasonCode

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

InstanceSavingsEstimationModeSource

When writing a match expression against InstanceSavingsEstimationModeSource, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your 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.

JobFilterName

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

JobStatus

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

LambdaFunctionMemoryMetricName

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

LambdaFunctionMemoryMetricStatistic

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

LambdaFunctionMetricName

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

LambdaFunctionMetricStatistic

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

LambdaFunctionRecommendationFilterName

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

LambdaFunctionRecommendationFinding

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

LambdaFunctionRecommendationFindingReasonCode

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

LambdaSavingsEstimationModeSource

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

LicenseEdition

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

LicenseFinding

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

LicenseFindingReasonCode

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

LicenseModel

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

LicenseName

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

LicenseRecommendationFilterName

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

LookBackPeriodPreference

When writing a match expression against LookBackPeriodPreference, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your 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.

MetricSourceProvider

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

MetricStatistic

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

MigrationEffort

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

Order

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

PlatformDifference

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

PreferredResourceName

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

RdsCurrentInstancePerformanceRisk

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

RdsEstimatedMonthlyVolumeIoPsCostVariation

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

RdsInstanceFinding

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

RdsInstanceFindingReasonCode

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

RdsSavingsEstimationModeSource

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

RdsStorageFinding

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

RdsStorageFindingReasonCode

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

RdsdbMetricName

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

RdsdbMetricStatistic

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

RdsdbRecommendationFilterName

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

RecommendationPreferenceName

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

RecommendationSourceType

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

ResourceType

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

SavingsEstimationMode

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

ScopeName

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

Status

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