pulumi-alicloud 3.78.0a1747200018__py3-none-any.whl → 3.79.0__py3-none-any.whl

pulumi_alicloud/ess/outputs.py

@@ -55,7 +55,11 @@ __all__ = [
     'GetScalingConfigurationsConfigurationInstancePatternInfoResult',
     'GetScalingConfigurationsConfigurationSpotPriceLimitResult',
     'GetScalingGroupsGroupResult',
+    'GetScalingGroupsGroupLaunchTemplateOverrideResult',
     'GetScalingRulesRuleResult',
+    'GetScalingRulesRuleHybridMetricResult',
+    'GetScalingRulesRuleHybridMetricDimensionResult',
+    'GetScalingRulesRuleStepAdjustmentResult',
     'GetScheduledTasksTaskResult',
 ]
 
@@ -3478,6 +3482,11 @@ class GetScalingGroupsGroupResult(dict):
                  active_scaling_configuration: builtins.str,
                  allocation_strategy: builtins.str,
                  az_balance: builtins.bool,
+                 capacity_options_compensate_with_on_demand: builtins.bool,
+                 capacity_options_on_demand_base_capacity: builtins.int,
+                 capacity_options_on_demand_percentage_above_base_capacity: builtins.int,
+                 capacity_options_spot_auto_replace_on_demand: builtins.bool,
+                 compensate_with_on_demand: builtins.bool,
                  cooldown_time: builtins.int,
                  creation_time: builtins.str,
                  db_instance_ids: Sequence[builtins.str],
@@ -3489,6 +3498,7 @@ class GetScalingGroupsGroupResult(dict):
                  id: builtins.str,
                  init_capacity: builtins.int,
                  launch_template_id: builtins.str,
+                 launch_template_overrides: Sequence['outputs.GetScalingGroupsGroupLaunchTemplateOverrideResult'],
                  launch_template_version: builtins.str,
                  lifecycle_state: builtins.str,
                  load_balancer_ids: Sequence[builtins.str],
@@ -3530,6 +3540,11 @@ class GetScalingGroupsGroupResult(dict):
         :param builtins.str active_scaling_configuration: Active scaling configuration for scaling group.
         :param builtins.str allocation_strategy: (Available since v1.242.0) The allocation policy of instances. Auto Scaling selects instance types based on the allocation policy to create instances. The allocation policy applies to pay-as-you-go and preemptible instances.
         :param builtins.bool az_balance: (Available since v1.242.0) Indicates whether instances in the scaling group are evenly distributed across multiple zones.
+        :param builtins.bool capacity_options_compensate_with_on_demand: (Available since v1.249.0) Indicates whether pay-as-you-go instances can be automatically created to meet the requirement on the number of ECS instances when the expected capacity of preemptible instances cannot be provided due to reasons such as cost-related issues and insufficient resources. This parameter is available only if you set MultiAZPolicy to COST_OPTIMIZED. Valid values: true, false.
+        :param builtins.int capacity_options_on_demand_base_capacity: (Available since v1.249.0) The minimum number of pay-as-you-go instances required in the scaling group. When the actual number of pay-as-you-go instances drops below the minimum threshold, Auto Scaling preferentially creates pay-as-you-go instances. Valid values: 0 to 1000.
+        :param builtins.int capacity_options_on_demand_percentage_above_base_capacity: (Available since v1.249.0) The percentage of pay-as-you-go instances in the excess instances when the minimum number of pay-as-you-go instances is reached. OnDemandBaseCapacity specifies the minimum number of pay-as-you-go instances that must be contained in the scaling group. Valid values: 0 to 100.
+        :param builtins.bool capacity_options_spot_auto_replace_on_demand: (Available since v1.249.0) Indicates whether pay-as-you-go instances can be replaced with preemptible instances. If you specify CompensateWithOnDemand, it may result in a higher percentage of pay-as-you-go instances compared to the value of OnDemandPercentageAboveBaseCapacity. If you specify this parameter, Auto Scaling preferentially deploys preemptible instances to replace the surplus pay-as-you-go instances when preemptible instance types are available. If you specify CompensateWithOnDemand, Auto Scaling creates pay-as-you-go instances when preemptible instance types are insufficient. To avoid retaining these pay-as-you-go instances for extended periods, Auto Scaling attempts to replace them with preemptible instances when sufficient preemptible instance types become available. Valid values: true, false.
+        :param builtins.bool compensate_with_on_demand: (Available since v1.249.0) Indicates whether pay-as-you-go instances can be automatically created to meet the requirement on the number of ECS instances when the expected capacity of preemptible instances cannot be provided due to reasons such as cost-related issues and insufficient resources. This parameter is available only if you set MultiAZPolicy to COST_OPTIMIZED. Valid values: true, false.
         :param builtins.int cooldown_time: Default cooldown time of scaling group.
         :param builtins.str creation_time: Creation time of scaling group.
         :param Sequence[builtins.str] db_instance_ids: Db instances id which the ECS instance attached to.
@@ -3541,6 +3556,7 @@ class GetScalingGroupsGroupResult(dict):
         :param builtins.str id: ID of the scaling group.
         :param builtins.int init_capacity: (Available since v1.242.0) The number of instances that are in the Initialized state and ready to be scaled out in the scaling group.
         :param builtins.str launch_template_id: Active launch template ID for scaling group.
+        :param Sequence['GetScalingGroupsGroupLaunchTemplateOverrideArgs'] launch_template_overrides: (Available since v1.249.0) The instance types that are specified by using the Extend Launch Template feature.
         :param builtins.str launch_template_version: Version of active launch template.
         :param builtins.str lifecycle_state: Lifecycle state of scaling group.
         :param Sequence[builtins.str] load_balancer_ids: Slb instances id which the ECS instance attached to.
@@ -3582,6 +3598,11 @@ class GetScalingGroupsGroupResult(dict):
         pulumi.set(__self__, "active_scaling_configuration", active_scaling_configuration)
         pulumi.set(__self__, "allocation_strategy", allocation_strategy)
         pulumi.set(__self__, "az_balance", az_balance)
+        pulumi.set(__self__, "capacity_options_compensate_with_on_demand", capacity_options_compensate_with_on_demand)
+        pulumi.set(__self__, "capacity_options_on_demand_base_capacity", capacity_options_on_demand_base_capacity)
+        pulumi.set(__self__, "capacity_options_on_demand_percentage_above_base_capacity", capacity_options_on_demand_percentage_above_base_capacity)
+        pulumi.set(__self__, "capacity_options_spot_auto_replace_on_demand", capacity_options_spot_auto_replace_on_demand)
+        pulumi.set(__self__, "compensate_with_on_demand", compensate_with_on_demand)
         pulumi.set(__self__, "cooldown_time", cooldown_time)
         pulumi.set(__self__, "creation_time", creation_time)
         pulumi.set(__self__, "db_instance_ids", db_instance_ids)
@@ -3593,6 +3614,7 @@ class GetScalingGroupsGroupResult(dict):
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "init_capacity", init_capacity)
         pulumi.set(__self__, "launch_template_id", launch_template_id)
+        pulumi.set(__self__, "launch_template_overrides", launch_template_overrides)
         pulumi.set(__self__, "launch_template_version", launch_template_version)
         pulumi.set(__self__, "lifecycle_state", lifecycle_state)
         pulumi.set(__self__, "load_balancer_ids", load_balancer_ids)
@@ -3662,6 +3684,46 @@ class GetScalingGroupsGroupResult(dict):
         """
         return pulumi.get(self, "az_balance")
 
+    @property
+    @pulumi.getter(name="capacityOptionsCompensateWithOnDemand")
+    def capacity_options_compensate_with_on_demand(self) -> builtins.bool:
+        """
+        (Available since v1.249.0) Indicates whether pay-as-you-go instances can be automatically created to meet the requirement on the number of ECS instances when the expected capacity of preemptible instances cannot be provided due to reasons such as cost-related issues and insufficient resources. This parameter is available only if you set MultiAZPolicy to COST_OPTIMIZED. Valid values: true, false.
+        """
+        return pulumi.get(self, "capacity_options_compensate_with_on_demand")
+
+    @property
+    @pulumi.getter(name="capacityOptionsOnDemandBaseCapacity")
+    def capacity_options_on_demand_base_capacity(self) -> builtins.int:
+        """
+        (Available since v1.249.0) The minimum number of pay-as-you-go instances required in the scaling group. When the actual number of pay-as-you-go instances drops below the minimum threshold, Auto Scaling preferentially creates pay-as-you-go instances. Valid values: 0 to 1000.
+        """
+        return pulumi.get(self, "capacity_options_on_demand_base_capacity")
+
+    @property
+    @pulumi.getter(name="capacityOptionsOnDemandPercentageAboveBaseCapacity")
+    def capacity_options_on_demand_percentage_above_base_capacity(self) -> builtins.int:
+        """
+        (Available since v1.249.0) The percentage of pay-as-you-go instances in the excess instances when the minimum number of pay-as-you-go instances is reached. OnDemandBaseCapacity specifies the minimum number of pay-as-you-go instances that must be contained in the scaling group. Valid values: 0 to 100.
+        """
+        return pulumi.get(self, "capacity_options_on_demand_percentage_above_base_capacity")
+
+    @property
+    @pulumi.getter(name="capacityOptionsSpotAutoReplaceOnDemand")
+    def capacity_options_spot_auto_replace_on_demand(self) -> builtins.bool:
+        """
+        (Available since v1.249.0) Indicates whether pay-as-you-go instances can be replaced with preemptible instances. If you specify CompensateWithOnDemand, it may result in a higher percentage of pay-as-you-go instances compared to the value of OnDemandPercentageAboveBaseCapacity. If you specify this parameter, Auto Scaling preferentially deploys preemptible instances to replace the surplus pay-as-you-go instances when preemptible instance types are available. If you specify CompensateWithOnDemand, Auto Scaling creates pay-as-you-go instances when preemptible instance types are insufficient. To avoid retaining these pay-as-you-go instances for extended periods, Auto Scaling attempts to replace them with preemptible instances when sufficient preemptible instance types become available. Valid values: true, false.
+        """
+        return pulumi.get(self, "capacity_options_spot_auto_replace_on_demand")
+
+    @property
+    @pulumi.getter(name="compensateWithOnDemand")
+    def compensate_with_on_demand(self) -> builtins.bool:
+        """
+        (Available since v1.249.0) Indicates whether pay-as-you-go instances can be automatically created to meet the requirement on the number of ECS instances when the expected capacity of preemptible instances cannot be provided due to reasons such as cost-related issues and insufficient resources. This parameter is available only if you set MultiAZPolicy to COST_OPTIMIZED. Valid values: true, false.
+        """
+        return pulumi.get(self, "compensate_with_on_demand")
+
     @property
     @pulumi.getter(name="cooldownTime")
     def cooldown_time(self) -> builtins.int:
@@ -3750,6 +3812,14 @@ class GetScalingGroupsGroupResult(dict):
         """
         return pulumi.get(self, "launch_template_id")
 
+    @property
+    @pulumi.getter(name="launchTemplateOverrides")
+    def launch_template_overrides(self) -> Sequence['outputs.GetScalingGroupsGroupLaunchTemplateOverrideResult']:
+        """
+        (Available since v1.249.0) The instance types that are specified by using the Extend Launch Template feature.
+        """
+        return pulumi.get(self, "launch_template_overrides")
+
     @property
     @pulumi.getter(name="launchTemplateVersion")
     def launch_template_version(self) -> builtins.str:
@@ -4039,57 +4109,121 @@ class GetScalingGroupsGroupResult(dict):
         return pulumi.get(self, "vswitch_ids")
 
 
+@pulumi.output_type
+class GetScalingGroupsGroupLaunchTemplateOverrideResult(dict):
+    def __init__(__self__, *,
+                 instance_type: builtins.str,
+                 spot_price_limit: builtins.float,
+                 weighted_capacity: builtins.int):
+        """
+        :param builtins.str instance_type: (Available since v1.249.0) The instance type. The instance type that is specified by this parameter overwrites the instance type that is specified in the launch template.
+        :param builtins.float spot_price_limit: (Available since v1.249.0) The maximum bid price of instance type N that is specified by LaunchTemplateOverride.N.InstanceType. You can specify N instance types by using the Extend Launch Template feature. Valid values of N: 1 to 10.
+        :param builtins.int weighted_capacity: (Available since v1.249.0) The weight of the instance type. The value of this parameter indicates the capacity of a single instance of the specified instance type in the scaling group. A greater weight indicates that a smaller number of instances of the specified instance type are required to reach the expected capacity.
+        """
+        pulumi.set(__self__, "instance_type", instance_type)
+        pulumi.set(__self__, "spot_price_limit", spot_price_limit)
+        pulumi.set(__self__, "weighted_capacity", weighted_capacity)
+
+    @property
+    @pulumi.getter(name="instanceType")
+    def instance_type(self) -> builtins.str:
+        """
+        (Available since v1.249.0) The instance type. The instance type that is specified by this parameter overwrites the instance type that is specified in the launch template.
+        """
+        return pulumi.get(self, "instance_type")
+
+    @property
+    @pulumi.getter(name="spotPriceLimit")
+    def spot_price_limit(self) -> builtins.float:
+        """
+        (Available since v1.249.0) The maximum bid price of instance type N that is specified by LaunchTemplateOverride.N.InstanceType. You can specify N instance types by using the Extend Launch Template feature. Valid values of N: 1 to 10.
+        """
+        return pulumi.get(self, "spot_price_limit")
+
+    @property
+    @pulumi.getter(name="weightedCapacity")
+    def weighted_capacity(self) -> builtins.int:
+        """
+        (Available since v1.249.0) The weight of the instance type. The value of this parameter indicates the capacity of a single instance of the specified instance type in the scaling group. A greater weight indicates that a smaller number of instances of the specified instance type are required to reach the expected capacity.
+        """
+        return pulumi.get(self, "weighted_capacity")
+
+
 @pulumi.output_type
 class GetScalingRulesRuleResult(dict):
     def __init__(__self__, *,
                  adjustment_type: builtins.str,
                  adjustment_value: builtins.int,
                  cooldown: builtins.int,
+                 disable_scale_in: builtins.bool,
+                 estimated_instance_warmup: builtins.int,
+                 hybrid_metrics: Sequence['outputs.GetScalingRulesRuleHybridMetricResult'],
+                 hybrid_monitor_namespace: builtins.str,
                  id: builtins.str,
                  initial_max_size: builtins.int,
                  metric_name: builtins.str,
+                 metric_type: builtins.str,
                  min_adjustment_magnitude: builtins.int,
                  name: builtins.str,
                  predictive_scaling_mode: builtins.str,
                  predictive_task_buffer_time: builtins.int,
                  predictive_value_behavior: builtins.str,
                  predictive_value_buffer: builtins.int,
+                 scale_in_evaluation_count: builtins.int,
+                 scale_out_evaluation_count: builtins.int,
                  scaling_group_id: builtins.str,
                  scaling_rule_ari: builtins.str,
+                 step_adjustments: Sequence['outputs.GetScalingRulesRuleStepAdjustmentResult'],
                  target_value: builtins.float,
                  type: builtins.str):
         """
         :param builtins.str adjustment_type: Adjustment type of the scaling rule.
         :param builtins.int adjustment_value: Adjustment value of the scaling rule.
         :param builtins.int cooldown: Cooldown time of the scaling rule.
-        :param builtins.str id: ID of the scaling rule.
+        :param builtins.bool disable_scale_in: (Available since v1.250.0) Indicates whether scale-in is disabled. This parameter is available only if you set ScalingRuleType to TargetTrackingScalingRule. Valid values: true, false.
+        :param builtins.int estimated_instance_warmup: (Available since v1.250.0) The warm-up period during which a series of preparation measures are taken on new instances. Auto Scaling does not monitor the metric data of instances that are being warmed up.
+        :param Sequence['GetScalingRulesRuleHybridMetricArgs'] hybrid_metrics: (Available since v1.250.0) The Hybrid Cloud Monitoring metrics.
+        :param builtins.str hybrid_monitor_namespace: (Available since v1.250.0) The ID of the Hybrid Cloud Monitoring namespace.
+        :param builtins.str id: (Available since v1.250.0) The reference ID of the metric in the metric expression.
         :param builtins.int initial_max_size: (Available since v1.242.0) The maximum number of ECS instances that can be added to the scaling group.
-        :param builtins.str metric_name: (Available since v1.242.0) The predefined metric of the scaling rule.
+        :param builtins.str metric_name: (Available since v1.250.0) The name of the Hybrid Cloud Monitoring metric.
+        :param builtins.str metric_type: (Available since v1.250.0) The type of the event-triggered task that is associated with the scaling rule.
         :param builtins.int min_adjustment_magnitude: Min adjustment magnitude of scaling rule.
         :param builtins.str name: Name of the scaling rule.
         :param builtins.str predictive_scaling_mode: (Available since v1.242.0) The mode of the predictive scaling rule.
         :param builtins.int predictive_task_buffer_time: (Available since v1.242.0) The amount of buffer time before the prediction task is executed. By default, all prediction tasks that are automatically created by a predictive scaling rule are executed on the hour. You can set a buffer time to execute prediction tasks and prepare resources in advance.
         :param builtins.str predictive_value_behavior: (Available since v1.242.0) The action on the predicted maximum value.
         :param builtins.int predictive_value_buffer: (Available since v1.242.0) The ratio based on which the predicted value is increased if you set predictive_value_behavior to PredictiveValueOverrideMaxWithBuffer. If the predicted value that is increased by this ratio is greater than the initial maximum capacity, the increased value is used as the maximum value for prediction tasks.
+        :param builtins.int scale_in_evaluation_count: (Available since v1.250.0) After you create a target tracking scaling rule, an event-triggered task is automatically created and associated with the scaling rule. This parameter defines the number of consecutive times the alert condition must be satisfied before the event-triggered task initiates a scale-in operation.
+        :param builtins.int scale_out_evaluation_count: (Available since v1.250.0) After you create a target tracking scaling rule, an event-triggered task is automatically created and associated with the scaling rule. This parameter defines the number of consecutive times the alert condition must be satisfied before the event-triggered task initiates a scale-out operation.
         :param builtins.str scaling_group_id: Scaling group id the scaling rules belong to.
         :param builtins.str scaling_rule_ari: Ari of scaling rule.
+        :param Sequence['GetScalingRulesRuleStepAdjustmentArgs'] step_adjustments: (Available since v1.250.0) The step adjustments of the step scaling rule.
         :param builtins.float target_value: (Available since v1.242.0) The target value of the metric.
         :param builtins.str type: Type of scaling rule.
         """
         pulumi.set(__self__, "adjustment_type", adjustment_type)
         pulumi.set(__self__, "adjustment_value", adjustment_value)
         pulumi.set(__self__, "cooldown", cooldown)
+        pulumi.set(__self__, "disable_scale_in", disable_scale_in)
+        pulumi.set(__self__, "estimated_instance_warmup", estimated_instance_warmup)
+        pulumi.set(__self__, "hybrid_metrics", hybrid_metrics)
+        pulumi.set(__self__, "hybrid_monitor_namespace", hybrid_monitor_namespace)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "initial_max_size", initial_max_size)
         pulumi.set(__self__, "metric_name", metric_name)
+        pulumi.set(__self__, "metric_type", metric_type)
         pulumi.set(__self__, "min_adjustment_magnitude", min_adjustment_magnitude)
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "predictive_scaling_mode", predictive_scaling_mode)
         pulumi.set(__self__, "predictive_task_buffer_time", predictive_task_buffer_time)
         pulumi.set(__self__, "predictive_value_behavior", predictive_value_behavior)
         pulumi.set(__self__, "predictive_value_buffer", predictive_value_buffer)
+        pulumi.set(__self__, "scale_in_evaluation_count", scale_in_evaluation_count)
+        pulumi.set(__self__, "scale_out_evaluation_count", scale_out_evaluation_count)
         pulumi.set(__self__, "scaling_group_id", scaling_group_id)
         pulumi.set(__self__, "scaling_rule_ari", scaling_rule_ari)
+        pulumi.set(__self__, "step_adjustments", step_adjustments)
         pulumi.set(__self__, "target_value", target_value)
         pulumi.set(__self__, "type", type)
 
@@ -4117,11 +4251,43 @@ class GetScalingRulesRuleResult(dict):
         """
         return pulumi.get(self, "cooldown")
 
+    @property
+    @pulumi.getter(name="disableScaleIn")
+    def disable_scale_in(self) -> builtins.bool:
+        """
+        (Available since v1.250.0) Indicates whether scale-in is disabled. This parameter is available only if you set ScalingRuleType to TargetTrackingScalingRule. Valid values: true, false.
+        """
+        return pulumi.get(self, "disable_scale_in")
+
+    @property
+    @pulumi.getter(name="estimatedInstanceWarmup")
+    def estimated_instance_warmup(self) -> builtins.int:
+        """
+        (Available since v1.250.0) The warm-up period during which a series of preparation measures are taken on new instances. Auto Scaling does not monitor the metric data of instances that are being warmed up.
+        """
+        return pulumi.get(self, "estimated_instance_warmup")
+
+    @property
+    @pulumi.getter(name="hybridMetrics")
+    def hybrid_metrics(self) -> Sequence['outputs.GetScalingRulesRuleHybridMetricResult']:
+        """
+        (Available since v1.250.0) The Hybrid Cloud Monitoring metrics.
+        """
+        return pulumi.get(self, "hybrid_metrics")
+
+    @property
+    @pulumi.getter(name="hybridMonitorNamespace")
+    def hybrid_monitor_namespace(self) -> builtins.str:
+        """
+        (Available since v1.250.0) The ID of the Hybrid Cloud Monitoring namespace.
+        """
+        return pulumi.get(self, "hybrid_monitor_namespace")
+
     @property
     @pulumi.getter
     def id(self) -> builtins.str:
         """
-        ID of the scaling rule.
+        (Available since v1.250.0) The reference ID of the metric in the metric expression.
         """
         return pulumi.get(self, "id")
 
@@ -4137,10 +4303,18 @@ class GetScalingRulesRuleResult(dict):
     @pulumi.getter(name="metricName")
     def metric_name(self) -> builtins.str:
         """
-        (Available since v1.242.0) The predefined metric of the scaling rule.
+        (Available since v1.250.0) The name of the Hybrid Cloud Monitoring metric.
         """
         return pulumi.get(self, "metric_name")
 
+    @property
+    @pulumi.getter(name="metricType")
+    def metric_type(self) -> builtins.str:
+        """
+        (Available since v1.250.0) The type of the event-triggered task that is associated with the scaling rule.
+        """
+        return pulumi.get(self, "metric_type")
+
     @property
     @pulumi.getter(name="minAdjustmentMagnitude")
     def min_adjustment_magnitude(self) -> builtins.int:
@@ -4189,6 +4363,22 @@ class GetScalingRulesRuleResult(dict):
         """
         return pulumi.get(self, "predictive_value_buffer")
 
+    @property
+    @pulumi.getter(name="scaleInEvaluationCount")
+    def scale_in_evaluation_count(self) -> builtins.int:
+        """
+        (Available since v1.250.0) After you create a target tracking scaling rule, an event-triggered task is automatically created and associated with the scaling rule. This parameter defines the number of consecutive times the alert condition must be satisfied before the event-triggered task initiates a scale-in operation.
+        """
+        return pulumi.get(self, "scale_in_evaluation_count")
+
+    @property
+    @pulumi.getter(name="scaleOutEvaluationCount")
+    def scale_out_evaluation_count(self) -> builtins.int:
+        """
+        (Available since v1.250.0) After you create a target tracking scaling rule, an event-triggered task is automatically created and associated with the scaling rule. This parameter defines the number of consecutive times the alert condition must be satisfied before the event-triggered task initiates a scale-out operation.
+        """
+        return pulumi.get(self, "scale_out_evaluation_count")
+
     @property
     @pulumi.getter(name="scalingGroupId")
     def scaling_group_id(self) -> builtins.str:
@@ -4205,6 +4395,14 @@ class GetScalingRulesRuleResult(dict):
         """
         return pulumi.get(self, "scaling_rule_ari")
 
+    @property
+    @pulumi.getter(name="stepAdjustments")
+    def step_adjustments(self) -> Sequence['outputs.GetScalingRulesRuleStepAdjustmentResult']:
+        """
+        (Available since v1.250.0) The step adjustments of the step scaling rule.
+        """
+        return pulumi.get(self, "step_adjustments")
+
     @property
     @pulumi.getter(name="targetValue")
     def target_value(self) -> builtins.float:
@@ -4222,6 +4420,137 @@ class GetScalingRulesRuleResult(dict):
         return pulumi.get(self, "type")
 
 
+@pulumi.output_type
+class GetScalingRulesRuleHybridMetricResult(dict):
+    def __init__(__self__, *,
+                 dimensions: Sequence['outputs.GetScalingRulesRuleHybridMetricDimensionResult'],
+                 expression: builtins.str,
+                 id: builtins.str,
+                 metric_name: builtins.str,
+                 statistic: builtins.str):
+        """
+        :param Sequence['GetScalingRulesRuleHybridMetricDimensionArgs'] dimensions: (Available since v1.250.0) The metric dimensions. You can use this parameter to specify the monitored resources.
+        :param builtins.str expression: (Available since v1.250.0) The metric expression that consists of multiple Hybrid Cloud Monitoring metrics. It calculates a result used to trigger scaling events. The expression is written in Reverse Polish Notation (RPN) format and includes only the following operators: +, -, *, /.
+        :param builtins.str id: (Available since v1.250.0) The reference ID of the metric in the metric expression.
+        :param builtins.str metric_name: (Available since v1.250.0) The name of the Hybrid Cloud Monitoring metric.
+        :param builtins.str statistic: (Available since v1.250.0) The statistical method of the metric data.
+        """
+        pulumi.set(__self__, "dimensions", dimensions)
+        pulumi.set(__self__, "expression", expression)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "metric_name", metric_name)
+        pulumi.set(__self__, "statistic", statistic)
+
+    @property
+    @pulumi.getter
+    def dimensions(self) -> Sequence['outputs.GetScalingRulesRuleHybridMetricDimensionResult']:
+        """
+        (Available since v1.250.0) The metric dimensions. You can use this parameter to specify the monitored resources.
+        """
+        return pulumi.get(self, "dimensions")
+
+    @property
+    @pulumi.getter
+    def expression(self) -> builtins.str:
+        """
+        (Available since v1.250.0) The metric expression that consists of multiple Hybrid Cloud Monitoring metrics. It calculates a result used to trigger scaling events. The expression is written in Reverse Polish Notation (RPN) format and includes only the following operators: +, -, *, /.
+        """
+        return pulumi.get(self, "expression")
+
+    @property
+    @pulumi.getter
+    def id(self) -> builtins.str:
+        """
+        (Available since v1.250.0) The reference ID of the metric in the metric expression.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="metricName")
+    def metric_name(self) -> builtins.str:
+        """
+        (Available since v1.250.0) The name of the Hybrid Cloud Monitoring metric.
+        """
+        return pulumi.get(self, "metric_name")
+
+    @property
+    @pulumi.getter
+    def statistic(self) -> builtins.str:
+        """
+        (Available since v1.250.0) The statistical method of the metric data.
+        """
+        return pulumi.get(self, "statistic")
+
+
+@pulumi.output_type
+class GetScalingRulesRuleHybridMetricDimensionResult(dict):
+    def __init__(__self__, *,
+                 dimension_key: builtins.str,
+                 dimension_value: builtins.str):
+        """
+        :param builtins.str dimension_key: (Available since v1.250.0) The dimension key of the metric.
+        :param builtins.str dimension_value: (Available since v1.250.0) The dimension value of the metric.
+        """
+        pulumi.set(__self__, "dimension_key", dimension_key)
+        pulumi.set(__self__, "dimension_value", dimension_value)
+
+    @property
+    @pulumi.getter(name="dimensionKey")
+    def dimension_key(self) -> builtins.str:
+        """
+        (Available since v1.250.0) The dimension key of the metric.
+        """
+        return pulumi.get(self, "dimension_key")
+
+    @property
+    @pulumi.getter(name="dimensionValue")
+    def dimension_value(self) -> builtins.str:
+        """
+        (Available since v1.250.0) The dimension value of the metric.
+        """
+        return pulumi.get(self, "dimension_value")
+
+
+@pulumi.output_type
+class GetScalingRulesRuleStepAdjustmentResult(dict):
+    def __init__(__self__, *,
+                 metric_interval_lower_bound: builtins.str,
+                 metric_interval_upper_bound: builtins.str,
+                 scaling_adjustment: builtins.int):
+        """
+        :param builtins.str metric_interval_lower_bound: (Available since v1.250.0) The lower limit of each step adjustment. Valid values: -9.999999E18 to 9.999999E18.
+        :param builtins.str metric_interval_upper_bound: (Available since v1.250.0) The upper limit of each step adjustment. Valid values: -9.999999E18 to 9.999999E18.
+        :param builtins.int scaling_adjustment: (Available since v1.250.0) The number of instances that are scaled in each step adjustment.
+        """
+        pulumi.set(__self__, "metric_interval_lower_bound", metric_interval_lower_bound)
+        pulumi.set(__self__, "metric_interval_upper_bound", metric_interval_upper_bound)
+        pulumi.set(__self__, "scaling_adjustment", scaling_adjustment)
+
+    @property
+    @pulumi.getter(name="metricIntervalLowerBound")
+    def metric_interval_lower_bound(self) -> builtins.str:
+        """
+        (Available since v1.250.0) The lower limit of each step adjustment. Valid values: -9.999999E18 to 9.999999E18.
+        """
+        return pulumi.get(self, "metric_interval_lower_bound")
+
+    @property
+    @pulumi.getter(name="metricIntervalUpperBound")
+    def metric_interval_upper_bound(self) -> builtins.str:
+        """
+        (Available since v1.250.0) The upper limit of each step adjustment. Valid values: -9.999999E18 to 9.999999E18.
+        """
+        return pulumi.get(self, "metric_interval_upper_bound")
+
+    @property
+    @pulumi.getter(name="scalingAdjustment")
+    def scaling_adjustment(self) -> builtins.int:
+        """
+        (Available since v1.250.0) The number of instances that are scaled in each step adjustment.
+        """
+        return pulumi.get(self, "scaling_adjustment")
+
+
 @pulumi.output_type
 class GetScheduledTasksTaskResult(dict):
     def __init__(__self__, *,