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.

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

• CustomizableMetricParameters

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

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

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

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

• EcsServiceProjectedMetric

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

• EcsServiceProjectedUtilizationMetric

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

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

• EcsServiceUtilizationMetric

  Describes the utilization metric of an Amazon ECS service.

• EffectivePreferredResource

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

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

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

• GetRecommendationError

  Describes an error experienced when getting recommendations.

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

• JobFilter

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

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

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

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

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

• ReasonCodeSummary

  A summary of a finding reason code.

• RecommendationExportJob

  Describes a recommendation export job.

• RecommendationPreferences

  Describes the recommendation preferences to return in the response of a GetAutoScalingGroupRecommendations, GetEC2InstanceRecommendations, and GetEC2RecommendationProjectedMetrics 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.

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

• SavingsOpportunity

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

• Scope

  Describes the scope of a recommendation preference.

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

• UtilizationPreference

  The preference to control the resource’s CPU utilization thresholds - threshold and headroom.

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