Module aws_sdk_computeoptimizer::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 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.

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

• 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 RDS recommendation option.

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

• RdsDatabaseRecommendedOptionProjectedMetric

  Describes the projected metrics of an Amazon RDS recommendation option.

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

• RdsEffectiveRecommendationPreferences

  Describes the effective recommendation preferences for Amazon RDS.

• RdsInstanceEstimatedMonthlySavings

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

• RdsInstanceSavingsOpportunityAfterDiscounts

  Describes the savings opportunity for Amazon RDS 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 Amazon RDS.

• RdsStorageEstimatedMonthlySavings

  Describes the estimated monthly savings possible for Amazon RDS storage by adopting Compute Optimizer recommendations. This is based on Amazon RDS 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 an Amazon RDS instance.

• RdsdbRecommendation

  Describes an Amazon RDS recommendation.

• RdsdbRecommendationFilter

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

• RdsdbStorageRecommendationOption

  Describes the recommendation options for Amazon RDS storage.

• RdsdbUtilizationMetric

  Describes the utilization metric of an Amazon RDS.

  To determine the performance difference between your current Amazon RDS 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

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