# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import builtins
import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities
from . import outputs

__all__ = [
    'ScalingConfigurationEip',
    'ScalingConfigurationInstanceTypeOverride',
    'ScalingConfigurationTag',
    'ScalingConfigurationVolume',
    'ScalingGroupInstancesDistribution',
    'ScalingGroupLaunchTemplateOverride',
    'ScalingGroupServerGroupAttribute',
    'ScalingGroupTag',
    'ScalingPolicyAlarmPolicy',
    'ScalingPolicyAlarmPolicyCondition',
    'ScalingPolicyScheduledPolicy',
    'GetScalingConfigurationEipResult',
    'GetScalingConfigurationInstanceTypeOverrideResult',
    'GetScalingConfigurationTagResult',
    'GetScalingConfigurationVolumeResult',
    'GetScalingGroupInstancesDistributionResult',
    'GetScalingGroupLaunchTemplateOverrideResult',
    'GetScalingGroupServerGroupAttributeResult',
    'GetScalingGroupTagResult',
    'GetScalingPolicyAlarmPolicyResult',
    'GetScalingPolicyAlarmPolicyConditionResult',
    'GetScalingPolicyScheduledPolicyResult',
]

@pulumi.output_type
class ScalingConfigurationEip(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bandwidthPackageId":
            suggest = "bandwidth_package_id"
        elif key == "billingType":
            suggest = "billing_type"
        elif key == "releaseWithInstance":
            suggest = "release_with_instance"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ScalingConfigurationEip. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ScalingConfigurationEip.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ScalingConfigurationEip.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bandwidth: Optional[builtins.int] = None,
                 bandwidth_package_id: Optional[builtins.str] = None,
                 billing_type: Optional[builtins.str] = None,
                 isp: Optional[builtins.str] = None,
                 release_with_instance: Optional[builtins.bool] = None):
        """
        :param builtins.int bandwidth: 公网IP的带宽峰值，默认为1，单位：Mbps。取值：当Eip.BillingType取值为PostPaidByBandwidth时，取值为1 ～ 500。当Eip.BillingType取值为PostPaidByTraffic时，取值为1 ～ 200。
        :param builtins.str bandwidth_package_id: 共享带宽包的ID，表示将公网IP加入到共享带宽包。 您可以调用 DescribeBandwidthPackages 接口，查询共享带宽包的ID。 公网IP加入到共享带宽包必须同时满足如下条件：二者的安全防护类型相同。二者的线路类型相同。共享带宽包为IPv4类型。
        :param builtins.str billing_type: 公网IP的计费类型，取值：PostPaidByBandwidth（默认）：按量计费-按带宽上限计费。PostPaidByTraffic：按量计费-按实际流量计费。
        :param builtins.str isp: 线路类型，取值：BGP（默认）：BGP线路。若您的账号已申请使用静态单线，ISP还可以传入ChinaMobile（表示中国移动）、ChinaTelecom（表示中国电信）、ChinaUnicom（表示中国联通）。
        :param builtins.bool release_with_instance: 公网IP是否随实例删除。仅按量计费公网IP且在ECS控制台删除实例时生效，在伸缩组中删除实例后公网IP的保留情况请参见实例管理中的详细说明。取值：true：公网IP随实例删除。false：公网IP不随实例删除。
        """
        if bandwidth is not None:
            pulumi.set(__self__, "bandwidth", bandwidth)
        if bandwidth_package_id is not None:
            pulumi.set(__self__, "bandwidth_package_id", bandwidth_package_id)
        if billing_type is not None:
            pulumi.set(__self__, "billing_type", billing_type)
        if isp is not None:
            pulumi.set(__self__, "isp", isp)
        if release_with_instance is not None:
            pulumi.set(__self__, "release_with_instance", release_with_instance)

    @property
    @pulumi.getter
    def bandwidth(self) -> Optional[builtins.int]:
        """
        公网IP的带宽峰值，默认为1，单位：Mbps。取值：当Eip.BillingType取值为PostPaidByBandwidth时，取值为1 ～ 500。当Eip.BillingType取值为PostPaidByTraffic时，取值为1 ～ 200。
        """
        return pulumi.get(self, "bandwidth")

    @property
    @pulumi.getter(name="bandwidthPackageId")
    def bandwidth_package_id(self) -> Optional[builtins.str]:
        """
        共享带宽包的ID，表示将公网IP加入到共享带宽包。 您可以调用 DescribeBandwidthPackages 接口，查询共享带宽包的ID。 公网IP加入到共享带宽包必须同时满足如下条件：二者的安全防护类型相同。二者的线路类型相同。共享带宽包为IPv4类型。
        """
        return pulumi.get(self, "bandwidth_package_id")

    @property
    @pulumi.getter(name="billingType")
    def billing_type(self) -> Optional[builtins.str]:
        """
        公网IP的计费类型，取值：PostPaidByBandwidth（默认）：按量计费-按带宽上限计费。PostPaidByTraffic：按量计费-按实际流量计费。
        """
        return pulumi.get(self, "billing_type")

    @property
    @pulumi.getter
    def isp(self) -> Optional[builtins.str]:
        """
        线路类型，取值：BGP（默认）：BGP线路。若您的账号已申请使用静态单线，ISP还可以传入ChinaMobile（表示中国移动）、ChinaTelecom（表示中国电信）、ChinaUnicom（表示中国联通）。
        """
        return pulumi.get(self, "isp")

    @property
    @pulumi.getter(name="releaseWithInstance")
    def release_with_instance(self) -> Optional[builtins.bool]:
        """
        公网IP是否随实例删除。仅按量计费公网IP且在ECS控制台删除实例时生效，在伸缩组中删除实例后公网IP的保留情况请参见实例管理中的详细说明。取值：true：公网IP随实例删除。false：公网IP不随实例删除。
        """
        return pulumi.get(self, "release_with_instance")


@pulumi.output_type
class ScalingConfigurationInstanceTypeOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceType":
            suggest = "instance_type"
        elif key == "priceLimit":
            suggest = "price_limit"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ScalingConfigurationInstanceTypeOverride. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ScalingConfigurationInstanceTypeOverride.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ScalingConfigurationInstanceTypeOverride.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 instance_type: Optional[builtins.str] = None,
                 price_limit: Optional[builtins.float] = None):
        """
        :param builtins.str instance_type: 指定抢占式实例的规格。参数   - N：表示实例规格的序号，取值为1 ～ 10。取值   - InstanceType：表示抢占式实例的规格。多个规格之间用&分隔。
        :param builtins.float price_limit: 指定抢占式实例规格每小时的最高价格参数   - N：表示实例规格的序号，取值为1 ～ 10。取值   - PriceLimit：表示抢占式实例规格每小时的最高价格。取值：大于0，且最大不超过3位小数。多个价格之间用&分隔。
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if price_limit is not None:
            pulumi.set(__self__, "price_limit", price_limit)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[builtins.str]:
        """
        指定抢占式实例的规格。参数   - N：表示实例规格的序号，取值为1 ～ 10。取值   - InstanceType：表示抢占式实例的规格。多个规格之间用&分隔。
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="priceLimit")
    def price_limit(self) -> Optional[builtins.float]:
        """
        指定抢占式实例规格每小时的最高价格参数   - N：表示实例规格的序号，取值为1 ～ 10。取值   - PriceLimit：表示抢占式实例规格每小时的最高价格。取值：大于0，且最大不超过3位小数。多个价格之间用&分隔。
        """
        return pulumi.get(self, "price_limit")


@pulumi.output_type
class ScalingConfigurationTag(dict):
    def __init__(__self__, *,
                 key: Optional[builtins.str] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str key: 标签键。
        :param builtins.str value: 标签值。
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[builtins.str]:
        """
        标签键。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        """
        标签值。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class ScalingConfigurationVolume(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deleteWithInstance":
            suggest = "delete_with_instance"
        elif key == "extraPerformanceIops":
            suggest = "extra_performance_iops"
        elif key == "extraPerformanceThroughputMb":
            suggest = "extra_performance_throughput_mb"
        elif key == "extraPerformanceTypeId":
            suggest = "extra_performance_type_id"
        elif key == "volumeType":
            suggest = "volume_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ScalingConfigurationVolume. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ScalingConfigurationVolume.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ScalingConfigurationVolume.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delete_with_instance: Optional[builtins.bool] = None,
                 extra_performance_iops: Optional[builtins.int] = None,
                 extra_performance_throughput_mb: Optional[builtins.int] = None,
                 extra_performance_type_id: Optional[builtins.str] = None,
                 size: Optional[builtins.int] = None,
                 volume_type: Optional[builtins.str] = None):
        """
        :param builtins.bool delete_with_instance: 云盘是否随实例释放：true（默认值）：云盘随实例释放。false：云盘不随实例释放。取值为false时对系统盘无效，系统盘默认随实例释放，不允许保留。
        :param builtins.int extra_performance_iops: 通过此参数可配置云盘额外性能包IOPS性能大小，仅ESSD FlexPL支持。参数   - N：表示云盘的序号，序号为“1”表示系统盘，序号为“2”或大于“2”表示数据盘，仅数据盘支持额外性能包，取值：2～16。ExtraPerformanceIOPS 表示第N个云盘的额外性能包IOPS大小：IOPS: 1-50000。Balance: 1-50000。
        :param builtins.int extra_performance_throughput_mb: 通过此参数可配置云盘额外性能包吞吐性能大小，单位MB/s，仅ESSD FlexPL支持。参数   - N：表示云盘的序号，序号为“1”表示系统盘，序号为“2”或大于“2”表示数据盘，仅数据盘支持额外性能包，取值：2～16。ExtraPerformanceThroughputMB 表示第N个云盘的额外性能包吞吐大小：Throughput：1-650。
        :param builtins.str extra_performance_type_id: 通过此参数可为云盘购买额外性能，仅ESSD FlexPL支持。参数   - N：表示云盘的序号，序号为“1”表示系统盘，序号为“2”或大于“2”表示数据盘，仅数据盘支持额外性能包。取值：2～16。ExtraPerformanceTypeId 表示第N个云盘的额外性能包类型：IOPS:IOPS型，使用ExtraPerformanceIOPS参数。Balance: 均衡型，使用ExtraPerformanceIOPS参数。Throughput：吞吐量型，使用ExtraPerformanceThroughputMB参数。
        :param builtins.int size: 云盘的容量，单位为GiB。系统盘取值范围：10   - 500。数据盘取值范围：10   - 8192。如果是 ESSD_FlexPL 并使用额外性能，大小必须 >= 500 GB。
        :param builtins.str volume_type: 云盘的类型：ESSD*FlexPL：极速型SSDFlexPL。ESSD*PL0：极速型SSD PL0。
        """
        if delete_with_instance is not None:
            pulumi.set(__self__, "delete_with_instance", delete_with_instance)
        if extra_performance_iops is not None:
            pulumi.set(__self__, "extra_performance_iops", extra_performance_iops)
        if extra_performance_throughput_mb is not None:
            pulumi.set(__self__, "extra_performance_throughput_mb", extra_performance_throughput_mb)
        if extra_performance_type_id is not None:
            pulumi.set(__self__, "extra_performance_type_id", extra_performance_type_id)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter(name="deleteWithInstance")
    def delete_with_instance(self) -> Optional[builtins.bool]:
        """
        云盘是否随实例释放：true（默认值）：云盘随实例释放。false：云盘不随实例释放。取值为false时对系统盘无效，系统盘默认随实例释放，不允许保留。
        """
        return pulumi.get(self, "delete_with_instance")

    @property
    @pulumi.getter(name="extraPerformanceIops")
    def extra_performance_iops(self) -> Optional[builtins.int]:
        """
        通过此参数可配置云盘额外性能包IOPS性能大小，仅ESSD FlexPL支持。参数   - N：表示云盘的序号，序号为“1”表示系统盘，序号为“2”或大于“2”表示数据盘，仅数据盘支持额外性能包，取值：2～16。ExtraPerformanceIOPS 表示第N个云盘的额外性能包IOPS大小：IOPS: 1-50000。Balance: 1-50000。
        """
        return pulumi.get(self, "extra_performance_iops")

    @property
    @pulumi.getter(name="extraPerformanceThroughputMb")
    def extra_performance_throughput_mb(self) -> Optional[builtins.int]:
        """
        通过此参数可配置云盘额外性能包吞吐性能大小，单位MB/s，仅ESSD FlexPL支持。参数   - N：表示云盘的序号，序号为“1”表示系统盘，序号为“2”或大于“2”表示数据盘，仅数据盘支持额外性能包，取值：2～16。ExtraPerformanceThroughputMB 表示第N个云盘的额外性能包吞吐大小：Throughput：1-650。
        """
        return pulumi.get(self, "extra_performance_throughput_mb")

    @property
    @pulumi.getter(name="extraPerformanceTypeId")
    def extra_performance_type_id(self) -> Optional[builtins.str]:
        """
        通过此参数可为云盘购买额外性能，仅ESSD FlexPL支持。参数   - N：表示云盘的序号，序号为“1”表示系统盘，序号为“2”或大于“2”表示数据盘，仅数据盘支持额外性能包。取值：2～16。ExtraPerformanceTypeId 表示第N个云盘的额外性能包类型：IOPS:IOPS型，使用ExtraPerformanceIOPS参数。Balance: 均衡型，使用ExtraPerformanceIOPS参数。Throughput：吞吐量型，使用ExtraPerformanceThroughputMB参数。
        """
        return pulumi.get(self, "extra_performance_type_id")

    @property
    @pulumi.getter
    def size(self) -> Optional[builtins.int]:
        """
        云盘的容量，单位为GiB。系统盘取值范围：10   - 500。数据盘取值范围：10   - 8192。如果是 ESSD_FlexPL 并使用额外性能，大小必须 >= 500 GB。
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[builtins.str]:
        """
        云盘的类型：ESSD*FlexPL：极速型SSDFlexPL。ESSD*PL0：极速型SSD PL0。
        """
        return pulumi.get(self, "volume_type")


@pulumi.output_type
class ScalingGroupInstancesDistribution(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "compensateWithOnDemand":
            suggest = "compensate_with_on_demand"
        elif key == "onDemandBaseCapacity":
            suggest = "on_demand_base_capacity"
        elif key == "onDemandPercentageAboveBaseCapacity":
            suggest = "on_demand_percentage_above_base_capacity"
        elif key == "spotInstanceRemedy":
            suggest = "spot_instance_remedy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ScalingGroupInstancesDistribution. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ScalingGroupInstancesDistribution.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ScalingGroupInstancesDistribution.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 compensate_with_on_demand: Optional[builtins.bool] = None,
                 on_demand_base_capacity: Optional[builtins.int] = None,
                 on_demand_percentage_above_base_capacity: Optional[builtins.int] = None,
                 spot_instance_remedy: Optional[builtins.bool] = None):
        """
        :param builtins.bool compensate_with_on_demand: 当因价格、库存等原因无法创建足够的抢占式实例时，是否允许使用按量实例补充抢占式容量。true: 允许。false（默认）: 不允许。
        :param builtins.int on_demand_base_capacity: 伸缩组中按量计费实例个数的最小值，取值范围：0~2000。当组中按量计费实例个数少于该值时，将优先创建按量计费的实例。
        :param builtins.int on_demand_percentage_above_base_capacity: 伸缩组满足最小按量实例数要求后，超出的实例中按量实例应占的比例，取值范围：0～100。
        :param builtins.bool spot_instance_remedy: 是否允许抢占式实例到期替换。开启则表示在抢占式实例被回收前5分钟左右，伸缩组将主动新建新的抢占式实例替换掉当前抢占式实例。true: 允许。false（默认）: 不允许。
        """
        if compensate_with_on_demand is not None:
            pulumi.set(__self__, "compensate_with_on_demand", compensate_with_on_demand)
        if on_demand_base_capacity is not None:
            pulumi.set(__self__, "on_demand_base_capacity", on_demand_base_capacity)
        if on_demand_percentage_above_base_capacity is not None:
            pulumi.set(__self__, "on_demand_percentage_above_base_capacity", on_demand_percentage_above_base_capacity)
        if spot_instance_remedy is not None:
            pulumi.set(__self__, "spot_instance_remedy", spot_instance_remedy)

    @property
    @pulumi.getter(name="compensateWithOnDemand")
    def compensate_with_on_demand(self) -> Optional[builtins.bool]:
        """
        当因价格、库存等原因无法创建足够的抢占式实例时，是否允许使用按量实例补充抢占式容量。true: 允许。false（默认）: 不允许。
        """
        return pulumi.get(self, "compensate_with_on_demand")

    @property
    @pulumi.getter(name="onDemandBaseCapacity")
    def on_demand_base_capacity(self) -> Optional[builtins.int]:
        """
        伸缩组中按量计费实例个数的最小值，取值范围：0~2000。当组中按量计费实例个数少于该值时，将优先创建按量计费的实例。
        """
        return pulumi.get(self, "on_demand_base_capacity")

    @property
    @pulumi.getter(name="onDemandPercentageAboveBaseCapacity")
    def on_demand_percentage_above_base_capacity(self) -> Optional[builtins.int]:
        """
        伸缩组满足最小按量实例数要求后，超出的实例中按量实例应占的比例，取值范围：0～100。
        """
        return pulumi.get(self, "on_demand_percentage_above_base_capacity")

    @property
    @pulumi.getter(name="spotInstanceRemedy")
    def spot_instance_remedy(self) -> Optional[builtins.bool]:
        """
        是否允许抢占式实例到期替换。开启则表示在抢占式实例被回收前5分钟左右，伸缩组将主动新建新的抢占式实例替换掉当前抢占式实例。true: 允许。false（默认）: 不允许。
        """
        return pulumi.get(self, "spot_instance_remedy")


@pulumi.output_type
class ScalingGroupLaunchTemplateOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceType":
            suggest = "instance_type"
        elif key == "priceLimit":
            suggest = "price_limit"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ScalingGroupLaunchTemplateOverride. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ScalingGroupLaunchTemplateOverride.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ScalingGroupLaunchTemplateOverride.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 instance_type: Optional[builtins.str] = None,
                 price_limit: Optional[builtins.float] = None):
        """
        :param builtins.str instance_type: 指定实例规格。本参数仅当LaunchTemplateId参数存在取值时生有效。
        :param builtins.float price_limit: 指定抢占式实例规格每小时的最高价格。本参数仅当LaunchTemplateId参数存在取值，且启动模版的计费模式为设置出价上限的抢占式实例（即SpotWithPriceLimit）时有效。
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if price_limit is not None:
            pulumi.set(__self__, "price_limit", price_limit)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[builtins.str]:
        """
        指定实例规格。本参数仅当LaunchTemplateId参数存在取值时生有效。
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="priceLimit")
    def price_limit(self) -> Optional[builtins.float]:
        """
        指定抢占式实例规格每小时的最高价格。本参数仅当LaunchTemplateId参数存在取值，且启动模版的计费模式为设置出价上限的抢占式实例（即SpotWithPriceLimit）时有效。
        """
        return pulumi.get(self, "price_limit")


@pulumi.output_type
class ScalingGroupServerGroupAttribute(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "serverGroupId":
            suggest = "server_group_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ScalingGroupServerGroupAttribute. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ScalingGroupServerGroupAttribute.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ScalingGroupServerGroupAttribute.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 port: Optional[builtins.int] = None,
                 server_group_id: Optional[builtins.str] = None,
                 type: Optional[builtins.str] = None,
                 weight: Optional[builtins.int] = None):
        """
        :param builtins.int port: 负载均衡后端服务器组中服务器的端口号。取值1 ～ 65535。
        :param builtins.str server_group_id: 负载均衡后端服务器组的ID。
        :param builtins.str type: 负载均衡服务器组类型。单个CLB/ALB最多支持添加20个后端服务器组，所有CLB/ALB最多支持添加100个后端服务器。ALB：应用型负载均衡。CLB：传统型型负载均衡（默认）。
        :param builtins.int weight: 负载均衡后端服务器组中服务器的权重。
        """
        if port is not None:
            pulumi.set(__self__, "port", port)
        if server_group_id is not None:
            pulumi.set(__self__, "server_group_id", server_group_id)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.int]:
        """
        负载均衡后端服务器组中服务器的端口号。取值1 ～ 65535。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="serverGroupId")
    def server_group_id(self) -> Optional[builtins.str]:
        """
        负载均衡后端服务器组的ID。
        """
        return pulumi.get(self, "server_group_id")

    @property
    @pulumi.getter
    def type(self) -> Optional[builtins.str]:
        """
        负载均衡服务器组类型。单个CLB/ALB最多支持添加20个后端服务器组，所有CLB/ALB最多支持添加100个后端服务器。ALB：应用型负载均衡。CLB：传统型型负载均衡（默认）。
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def weight(self) -> Optional[builtins.int]:
        """
        负载均衡后端服务器组中服务器的权重。
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class ScalingGroupTag(dict):
    def __init__(__self__, *,
                 key: Optional[builtins.str] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str key: 用户标签的标签键。
        :param builtins.str value: 用户标签的标签值。
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[builtins.str]:
        """
        用户标签的标签键。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        """
        用户标签的标签值。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class ScalingPolicyAlarmPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionOperator":
            suggest = "condition_operator"
        elif key == "evaluationCount":
            suggest = "evaluation_count"
        elif key == "ruleType":
            suggest = "rule_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ScalingPolicyAlarmPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ScalingPolicyAlarmPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ScalingPolicyAlarmPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 condition: Optional['outputs.ScalingPolicyAlarmPolicyCondition'] = None,
                 condition_operator: Optional[builtins.str] = None,
                 conditions: Optional[Sequence['outputs.ScalingPolicyAlarmPolicyCondition']] = None,
                 effective: Optional[builtins.str] = None,
                 evaluation_count: Optional[builtins.int] = None,
                 rule_type: Optional[builtins.str] = None):
        """
        :param 'ScalingPolicyAlarmPolicyConditionArgs' condition: 单指标监控时的监控指标详细信息。仅当ScalingPolicyType取值为Alarm时有效。
        :param builtins.str condition_operator: 多指标告警时的判定条件。&&：多个指标同时成立才判定为触发告警。||（默认）：任意指标满足条件就判定为触发告警。
        :param builtins.str effective: 报警任务的生效时间段。
        :param builtins.int evaluation_count: 当监控指标数据连续几次达到阈值时，即触发伸缩行为。仅当ScalingPolicyType取值为Alarm时有效且为必填项。
        :param builtins.str rule_type: 报警任务的类型，取值：Static：表示由agent采集的静态监控。仅当ScalingPolicyType取值为Alarm时有效且为必填项。
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if condition_operator is not None:
            pulumi.set(__self__, "condition_operator", condition_operator)
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)
        if effective is not None:
            pulumi.set(__self__, "effective", effective)
        if evaluation_count is not None:
            pulumi.set(__self__, "evaluation_count", evaluation_count)
        if rule_type is not None:
            pulumi.set(__self__, "rule_type", rule_type)

    @property
    @pulumi.getter
    def condition(self) -> Optional['outputs.ScalingPolicyAlarmPolicyCondition']:
        """
        单指标监控时的监控指标详细信息。仅当ScalingPolicyType取值为Alarm时有效。
        """
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter(name="conditionOperator")
    def condition_operator(self) -> Optional[builtins.str]:
        """
        多指标告警时的判定条件。&&：多个指标同时成立才判定为触发告警。||（默认）：任意指标满足条件就判定为触发告警。
        """
        return pulumi.get(self, "condition_operator")

    @property
    @pulumi.getter
    def conditions(self) -> Optional[Sequence['outputs.ScalingPolicyAlarmPolicyCondition']]:
        return pulumi.get(self, "conditions")

    @property
    @pulumi.getter
    def effective(self) -> Optional[builtins.str]:
        """
        报警任务的生效时间段。
        """
        return pulumi.get(self, "effective")

    @property
    @pulumi.getter(name="evaluationCount")
    def evaluation_count(self) -> Optional[builtins.int]:
        """
        当监控指标数据连续几次达到阈值时，即触发伸缩行为。仅当ScalingPolicyType取值为Alarm时有效且为必填项。
        """
        return pulumi.get(self, "evaluation_count")

    @property
    @pulumi.getter(name="ruleType")
    def rule_type(self) -> Optional[builtins.str]:
        """
        报警任务的类型，取值：Static：表示由agent采集的静态监控。仅当ScalingPolicyType取值为Alarm时有效且为必填项。
        """
        return pulumi.get(self, "rule_type")


@pulumi.output_type
class ScalingPolicyAlarmPolicyCondition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "comparisonOperator":
            suggest = "comparison_operator"
        elif key == "metricName":
            suggest = "metric_name"
        elif key == "metricUnit":
            suggest = "metric_unit"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ScalingPolicyAlarmPolicyCondition. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ScalingPolicyAlarmPolicyCondition.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ScalingPolicyAlarmPolicyCondition.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 comparison_operator: Optional[builtins.str] = None,
                 metric_name: Optional[builtins.str] = None,
                 metric_unit: Optional[builtins.str] = None,
                 threshold: Optional[builtins.str] = None):
        """
        :param builtins.str comparison_operator: 指标告警时的规则表达式对象。>：大于。<：小于。=：等于。
        :param builtins.str metric_name: 指标告警时的监控指标名称。CpuTotal*Max：带内CPU使用率最大值。CpuTotal*Min：带内CPU使用率最小值。CpuTotal*Avg：带内CPU使用率平均值。MemoryUsedUtilization*Max：带内内存使用率最大值。MemoryUsedUtilization*Min：带内内存使用率最小值。MemoryUsedUtilization*Avg：带内内存使用率平均值。Instance*CpuBusy*Max：带外CPU利用率最大值。Instance*CpuBusy*Min：带外CPU利用率最小值。Instance*CpuBusy*Avg：带外CPU利用率平均值。Instance*NetTxBits*Avg: 带外网络流出速率平均值。Instance*NetRxBits*Avg: 带外网络流入速率平均值。Instance*NetTxPackets*Avg: 带外网络发送包速率平均值。Instance*NetRxPackets*Avg: 带外网络接收包速率平均值。SystemDiskReadBytes*Avg: 带内系统盘读带宽平均值。SystemDiskWriteBytes*Avg: 带内系统盘写带宽平均值。SystemDiskReadIOPS*Avg: 带内系统盘读IOPS平均值。SystemDiskWriteIOPS*Avg: 带内系统盘写IOPS平均值。NetTcpConnection_Avg: 带内TCP连接数平均值。
        :param builtins.str metric_unit: 指标告警时的监控指标阈值的单位。当AlarmPolicy.Conditions.MetricName参数取值为CPU/内存使用率时: Percent。当AlarmPolicy.Conditions.MetricName参数取值为系统盘读/写带宽时: Bytes/Second(IEC)。当AlarmPolicy.Conditions.MetricName参数取值为系统盘读/写IOPS时: Count/Second。当AlarmPolicy.Conditions.MetricName参数取值为TCP连接数时: Count。当AlarmPolicy.Condition.MetricName参数取值为网络流入/流出速率时: Bits/Second(IEC)。当AlarmPolicy.Condition.MetricName参数取值为网络收发包速率时: Packet/Second。
        :param builtins.str threshold: 指标告警时的监控指标的阈值。当AlarmPolicy.Conditions.MetricUnit取值为Percent时：1 ～ 100。当AlarmPolicy.Conditions.MetricUnit取值为Bytes/Second(IEC)时：大于0的整数。当AlarmPolicy.Conditions.MetricUnit取值为Count/Second时：大于0的整数。当AlarmPolicy.Conditions.MetricUnit取值为Count时：大于0的整数。当AlarmPolicy.Condition.MetricUnit取值为Bits/Second(IEC)时：大于0的整数。当AlarmPolicy.Condition.MetricUnit取值为Packet/Second时：大于0的整数。
        """
        if comparison_operator is not None:
            pulumi.set(__self__, "comparison_operator", comparison_operator)
        if metric_name is not None:
            pulumi.set(__self__, "metric_name", metric_name)
        if metric_unit is not None:
            pulumi.set(__self__, "metric_unit", metric_unit)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> Optional[builtins.str]:
        """
        指标告警时的规则表达式对象。>：大于。<：小于。=：等于。
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> Optional[builtins.str]:
        """
        指标告警时的监控指标名称。CpuTotal*Max：带内CPU使用率最大值。CpuTotal*Min：带内CPU使用率最小值。CpuTotal*Avg：带内CPU使用率平均值。MemoryUsedUtilization*Max：带内内存使用率最大值。MemoryUsedUtilization*Min：带内内存使用率最小值。MemoryUsedUtilization*Avg：带内内存使用率平均值。Instance*CpuBusy*Max：带外CPU利用率最大值。Instance*CpuBusy*Min：带外CPU利用率最小值。Instance*CpuBusy*Avg：带外CPU利用率平均值。Instance*NetTxBits*Avg: 带外网络流出速率平均值。Instance*NetRxBits*Avg: 带外网络流入速率平均值。Instance*NetTxPackets*Avg: 带外网络发送包速率平均值。Instance*NetRxPackets*Avg: 带外网络接收包速率平均值。SystemDiskReadBytes*Avg: 带内系统盘读带宽平均值。SystemDiskWriteBytes*Avg: 带内系统盘写带宽平均值。SystemDiskReadIOPS*Avg: 带内系统盘读IOPS平均值。SystemDiskWriteIOPS*Avg: 带内系统盘写IOPS平均值。NetTcpConnection_Avg: 带内TCP连接数平均值。
        """
        return pulumi.get(self, "metric_name")

    @property
    @pulumi.getter(name="metricUnit")
    def metric_unit(self) -> Optional[builtins.str]:
        """
        指标告警时的监控指标阈值的单位。当AlarmPolicy.Conditions.MetricName参数取值为CPU/内存使用率时: Percent。当AlarmPolicy.Conditions.MetricName参数取值为系统盘读/写带宽时: Bytes/Second(IEC)。当AlarmPolicy.Conditions.MetricName参数取值为系统盘读/写IOPS时: Count/Second。当AlarmPolicy.Conditions.MetricName参数取值为TCP连接数时: Count。当AlarmPolicy.Condition.MetricName参数取值为网络流入/流出速率时: Bits/Second(IEC)。当AlarmPolicy.Condition.MetricName参数取值为网络收发包速率时: Packet/Second。
        """
        return pulumi.get(self, "metric_unit")

    @property
    @pulumi.getter
    def threshold(self) -> Optional[builtins.str]:
        """
        指标告警时的监控指标的阈值。当AlarmPolicy.Conditions.MetricUnit取值为Percent时：1 ～ 100。当AlarmPolicy.Conditions.MetricUnit取值为Bytes/Second(IEC)时：大于0的整数。当AlarmPolicy.Conditions.MetricUnit取值为Count/Second时：大于0的整数。当AlarmPolicy.Conditions.MetricUnit取值为Count时：大于0的整数。当AlarmPolicy.Condition.MetricUnit取值为Bits/Second(IEC)时：大于0的整数。当AlarmPolicy.Condition.MetricUnit取值为Packet/Second时：大于0的整数。
        """
        return pulumi.get(self, "threshold")


@pulumi.output_type
class ScalingPolicyScheduledPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "launchTime":
            suggest = "launch_time"
        elif key == "launchTimeRead":
            suggest = "launch_time_read"
        elif key == "recurrenceEndTime":
            suggest = "recurrence_end_time"
        elif key == "recurrenceEndTimeRead":
            suggest = "recurrence_end_time_read"
        elif key == "recurrenceStartTime":
            suggest = "recurrence_start_time"
        elif key == "recurrenceType":
            suggest = "recurrence_type"
        elif key == "recurrenceValue":
            suggest = "recurrence_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ScalingPolicyScheduledPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ScalingPolicyScheduledPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ScalingPolicyScheduledPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 launch_time: Optional[builtins.str] = None,
                 launch_time_read: Optional[builtins.str] = None,
                 recurrence_end_time: Optional[builtins.str] = None,
                 recurrence_end_time_read: Optional[builtins.str] = None,
                 recurrence_start_time: Optional[builtins.str] = None,
                 recurrence_type: Optional[builtins.str] = None,
                 recurrence_value: Optional[builtins.str] = None):
        """
        :param builtins.str launch_time: 表示任务的触发时间，默认为此刻。当ScalingPolicyType值为Scheduled时，表示定时任务的触发时间。当ScalingPolicyType值为Recurrence时：如果ScheduledPolicy.RecurrenceType为空，则表示仅按照此处指定的日期和时间执行一次。如果ScheduledPolicy.RecurrenceType不为空，则表示周期任务开始时间。
        :param builtins.str launch_time_read: 表示任务的触发时间。只读字段，修改或创建使用LaunchTime。
        :param builtins.str recurrence_end_time: 表示周期任务的结束时间。仅支持选择自创建当日起365日内的时间。若不配置，则根据重复周期（ScheduledPolicy.RecurrenceType）默认为此刻后的一天/周/月。设置为空，表示本任务永不停止。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        :param builtins.str recurrence_end_time_read: 表示周期任务的结束时间。只读字段，修改或创建使用RecurrenceEndTime。
        :param builtins.str recurrence_start_time: 表示周期任务的开始执行时间。当ScalingPolicyType取值为Recurrence时有效。
        :param builtins.str recurrence_type: 表示周期任务的重复周期，取值：Daily：每XX天执行一次。Weekly：选择每周中的几天，每天执行一次。Monthly：选择每月中XX号到XX号，每天执行一次。Cron：按照指定的Cron表达式执行。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        :param builtins.str recurrence_value: 表示重复执行周期任务的数值。当ScheduledPolicy.RecurrenceType参数取值为Daily时，只能填写一个值，取值：1   - 31。当ScheduledPolicy.RecurrenceType参数取值为Weekly时，可以填入多个值，使用英文逗号（,）分隔。星期一到星期日的取值依次为：1,2,3,4,5,6,7。当ScheduledPolicy.RecurrenceType参数取值为Monthly时，格式为A-B。A、B的取值范围均为1-31，且B必须大于等于A。当ScheduledPolicy.RecurrenceType参数取值为Cron 时，表示UTC+8时间，支持分、时、日、月、星期的5域表达式，支持通配符英文逗号（,）、英文问号（?）、连词符（-）、星号（*）、井号（#）、斜线（/）、L和W。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        """
        if launch_time is not None:
            pulumi.set(__self__, "launch_time", launch_time)
        if launch_time_read is not None:
            pulumi.set(__self__, "launch_time_read", launch_time_read)
        if recurrence_end_time is not None:
            pulumi.set(__self__, "recurrence_end_time", recurrence_end_time)
        if recurrence_end_time_read is not None:
            pulumi.set(__self__, "recurrence_end_time_read", recurrence_end_time_read)
        if recurrence_start_time is not None:
            pulumi.set(__self__, "recurrence_start_time", recurrence_start_time)
        if recurrence_type is not None:
            pulumi.set(__self__, "recurrence_type", recurrence_type)
        if recurrence_value is not None:
            pulumi.set(__self__, "recurrence_value", recurrence_value)

    @property
    @pulumi.getter(name="launchTime")
    def launch_time(self) -> Optional[builtins.str]:
        """
        表示任务的触发时间，默认为此刻。当ScalingPolicyType值为Scheduled时，表示定时任务的触发时间。当ScalingPolicyType值为Recurrence时：如果ScheduledPolicy.RecurrenceType为空，则表示仅按照此处指定的日期和时间执行一次。如果ScheduledPolicy.RecurrenceType不为空，则表示周期任务开始时间。
        """
        return pulumi.get(self, "launch_time")

    @property
    @pulumi.getter(name="launchTimeRead")
    def launch_time_read(self) -> Optional[builtins.str]:
        """
        表示任务的触发时间。只读字段，修改或创建使用LaunchTime。
        """
        return pulumi.get(self, "launch_time_read")

    @property
    @pulumi.getter(name="recurrenceEndTime")
    def recurrence_end_time(self) -> Optional[builtins.str]:
        """
        表示周期任务的结束时间。仅支持选择自创建当日起365日内的时间。若不配置，则根据重复周期（ScheduledPolicy.RecurrenceType）默认为此刻后的一天/周/月。设置为空，表示本任务永不停止。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        """
        return pulumi.get(self, "recurrence_end_time")

    @property
    @pulumi.getter(name="recurrenceEndTimeRead")
    def recurrence_end_time_read(self) -> Optional[builtins.str]:
        """
        表示周期任务的结束时间。只读字段，修改或创建使用RecurrenceEndTime。
        """
        return pulumi.get(self, "recurrence_end_time_read")

    @property
    @pulumi.getter(name="recurrenceStartTime")
    def recurrence_start_time(self) -> Optional[builtins.str]:
        """
        表示周期任务的开始执行时间。当ScalingPolicyType取值为Recurrence时有效。
        """
        return pulumi.get(self, "recurrence_start_time")

    @property
    @pulumi.getter(name="recurrenceType")
    def recurrence_type(self) -> Optional[builtins.str]:
        """
        表示周期任务的重复周期，取值：Daily：每XX天执行一次。Weekly：选择每周中的几天，每天执行一次。Monthly：选择每月中XX号到XX号，每天执行一次。Cron：按照指定的Cron表达式执行。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        """
        return pulumi.get(self, "recurrence_type")

    @property
    @pulumi.getter(name="recurrenceValue")
    def recurrence_value(self) -> Optional[builtins.str]:
        """
        表示重复执行周期任务的数值。当ScheduledPolicy.RecurrenceType参数取值为Daily时，只能填写一个值，取值：1   - 31。当ScheduledPolicy.RecurrenceType参数取值为Weekly时，可以填入多个值，使用英文逗号（,）分隔。星期一到星期日的取值依次为：1,2,3,4,5,6,7。当ScheduledPolicy.RecurrenceType参数取值为Monthly时，格式为A-B。A、B的取值范围均为1-31，且B必须大于等于A。当ScheduledPolicy.RecurrenceType参数取值为Cron 时，表示UTC+8时间，支持分、时、日、月、星期的5域表达式，支持通配符英文逗号（,）、英文问号（?）、连词符（-）、星号（*）、井号（#）、斜线（/）、L和W。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        """
        return pulumi.get(self, "recurrence_value")


@pulumi.output_type
class GetScalingConfigurationEipResult(dict):
    def __init__(__self__, *,
                 bandwidth: builtins.int,
                 bandwidth_package_id: builtins.str,
                 billing_type: builtins.str,
                 isp: builtins.str,
                 release_with_instance: builtins.bool):
        """
        :param builtins.int bandwidth: 公网IP的带宽峰值，默认为1，单位：Mbps。取值：当Eip.BillingType取值为PostPaidByBandwidth时，取值为1 ～ 500。当Eip.BillingType取值为PostPaidByTraffic时，取值为1 ～ 200。
        :param builtins.str bandwidth_package_id: 共享带宽包的ID，表示将公网IP加入到共享带宽包。 您可以调用 DescribeBandwidthPackages 接口，查询共享带宽包的ID。 公网IP加入到共享带宽包必须同时满足如下条件：二者的安全防护类型相同。二者的线路类型相同。共享带宽包为IPv4类型。
        :param builtins.str billing_type: 公网IP的计费类型，取值：PostPaidByBandwidth（默认）：按量计费-按带宽上限计费。PostPaidByTraffic：按量计费-按实际流量计费。
        :param builtins.str isp: 线路类型，取值：BGP（默认）：BGP线路。若您的账号已申请使用静态单线，ISP还可以传入ChinaMobile（表示中国移动）、ChinaTelecom（表示中国电信）、ChinaUnicom（表示中国联通）。
        :param builtins.bool release_with_instance: 公网IP是否随实例删除。仅按量计费公网IP且在ECS控制台删除实例时生效，在伸缩组中删除实例后公网IP的保留情况请参见实例管理中的详细说明。取值：true：公网IP随实例删除。false：公网IP不随实例删除。
        """
        pulumi.set(__self__, "bandwidth", bandwidth)
        pulumi.set(__self__, "bandwidth_package_id", bandwidth_package_id)
        pulumi.set(__self__, "billing_type", billing_type)
        pulumi.set(__self__, "isp", isp)
        pulumi.set(__self__, "release_with_instance", release_with_instance)

    @property
    @pulumi.getter
    def bandwidth(self) -> builtins.int:
        """
        公网IP的带宽峰值，默认为1，单位：Mbps。取值：当Eip.BillingType取值为PostPaidByBandwidth时，取值为1 ～ 500。当Eip.BillingType取值为PostPaidByTraffic时，取值为1 ～ 200。
        """
        return pulumi.get(self, "bandwidth")

    @property
    @pulumi.getter(name="bandwidthPackageId")
    def bandwidth_package_id(self) -> builtins.str:
        """
        共享带宽包的ID，表示将公网IP加入到共享带宽包。 您可以调用 DescribeBandwidthPackages 接口，查询共享带宽包的ID。 公网IP加入到共享带宽包必须同时满足如下条件：二者的安全防护类型相同。二者的线路类型相同。共享带宽包为IPv4类型。
        """
        return pulumi.get(self, "bandwidth_package_id")

    @property
    @pulumi.getter(name="billingType")
    def billing_type(self) -> builtins.str:
        """
        公网IP的计费类型，取值：PostPaidByBandwidth（默认）：按量计费-按带宽上限计费。PostPaidByTraffic：按量计费-按实际流量计费。
        """
        return pulumi.get(self, "billing_type")

    @property
    @pulumi.getter
    def isp(self) -> builtins.str:
        """
        线路类型，取值：BGP（默认）：BGP线路。若您的账号已申请使用静态单线，ISP还可以传入ChinaMobile（表示中国移动）、ChinaTelecom（表示中国电信）、ChinaUnicom（表示中国联通）。
        """
        return pulumi.get(self, "isp")

    @property
    @pulumi.getter(name="releaseWithInstance")
    def release_with_instance(self) -> builtins.bool:
        """
        公网IP是否随实例删除。仅按量计费公网IP且在ECS控制台删除实例时生效，在伸缩组中删除实例后公网IP的保留情况请参见实例管理中的详细说明。取值：true：公网IP随实例删除。false：公网IP不随实例删除。
        """
        return pulumi.get(self, "release_with_instance")


@pulumi.output_type
class GetScalingConfigurationInstanceTypeOverrideResult(dict):
    def __init__(__self__, *,
                 instance_type: builtins.str,
                 price_limit: builtins.float):
        """
        :param builtins.str instance_type: 指定抢占式实例的规格。参数   - N：表示实例规格的序号，取值为1 ～ 10。取值   - InstanceType：表示抢占式实例的规格。多个规格之间用&分隔。
        :param builtins.float price_limit: 指定抢占式实例规格每小时的最高价格参数   - N：表示实例规格的序号，取值为1 ～ 10。取值   - PriceLimit：表示抢占式实例规格每小时的最高价格。取值：大于0，且最大不超过3位小数。多个价格之间用&分隔。
        """
        pulumi.set(__self__, "instance_type", instance_type)
        pulumi.set(__self__, "price_limit", price_limit)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> builtins.str:
        """
        指定抢占式实例的规格。参数   - N：表示实例规格的序号，取值为1 ～ 10。取值   - InstanceType：表示抢占式实例的规格。多个规格之间用&分隔。
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="priceLimit")
    def price_limit(self) -> builtins.float:
        """
        指定抢占式实例规格每小时的最高价格参数   - N：表示实例规格的序号，取值为1 ～ 10。取值   - PriceLimit：表示抢占式实例规格每小时的最高价格。取值：大于0，且最大不超过3位小数。多个价格之间用&分隔。
        """
        return pulumi.get(self, "price_limit")


@pulumi.output_type
class GetScalingConfigurationTagResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 value: builtins.str):
        """
        :param builtins.str key: 标签键。
        :param builtins.str value: 标签值。
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        标签键。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        """
        标签值。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetScalingConfigurationVolumeResult(dict):
    def __init__(__self__, *,
                 delete_with_instance: builtins.bool,
                 extra_performance_iops: builtins.int,
                 extra_performance_throughput_mb: builtins.int,
                 extra_performance_type_id: builtins.str,
                 size: builtins.int,
                 volume_type: builtins.str):
        """
        :param builtins.bool delete_with_instance: 云盘是否随实例释放：true（默认值）：云盘随实例释放。false：云盘不随实例释放。取值为false时对系统盘无效，系统盘默认随实例释放，不允许保留。
        :param builtins.int extra_performance_iops: 通过此参数可配置云盘额外性能包IOPS性能大小，仅ESSD FlexPL支持。参数   - N：表示云盘的序号，序号为“1”表示系统盘，序号为“2”或大于“2”表示数据盘，仅数据盘支持额外性能包，取值：2～16。ExtraPerformanceIOPS 表示第N个云盘的额外性能包IOPS大小：IOPS: 1-50000。Balance: 1-50000。
        :param builtins.int extra_performance_throughput_mb: 通过此参数可配置云盘额外性能包吞吐性能大小，单位MB/s，仅ESSD FlexPL支持。参数   - N：表示云盘的序号，序号为“1”表示系统盘，序号为“2”或大于“2”表示数据盘，仅数据盘支持额外性能包，取值：2～16。ExtraPerformanceThroughputMB 表示第N个云盘的额外性能包吞吐大小：Throughput：1-650。
        :param builtins.str extra_performance_type_id: 通过此参数可为云盘购买额外性能，仅ESSD FlexPL支持。参数   - N：表示云盘的序号，序号为“1”表示系统盘，序号为“2”或大于“2”表示数据盘，仅数据盘支持额外性能包。取值：2～16。ExtraPerformanceTypeId 表示第N个云盘的额外性能包类型：IOPS:IOPS型，使用ExtraPerformanceIOPS参数。Balance: 均衡型，使用ExtraPerformanceIOPS参数。Throughput：吞吐量型，使用ExtraPerformanceThroughputMB参数。
        :param builtins.int size: 云盘的容量，单位为GiB。系统盘取值范围：10   - 500。数据盘取值范围：10   - 8192。如果是 ESSD_FlexPL 并使用额外性能，大小必须 >= 500 GB。
        :param builtins.str volume_type: 云盘的类型：ESSD*FlexPL：极速型SSDFlexPL。ESSD*PL0：极速型SSD PL0。
        """
        pulumi.set(__self__, "delete_with_instance", delete_with_instance)
        pulumi.set(__self__, "extra_performance_iops", extra_performance_iops)
        pulumi.set(__self__, "extra_performance_throughput_mb", extra_performance_throughput_mb)
        pulumi.set(__self__, "extra_performance_type_id", extra_performance_type_id)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter(name="deleteWithInstance")
    def delete_with_instance(self) -> builtins.bool:
        """
        云盘是否随实例释放：true（默认值）：云盘随实例释放。false：云盘不随实例释放。取值为false时对系统盘无效，系统盘默认随实例释放，不允许保留。
        """
        return pulumi.get(self, "delete_with_instance")

    @property
    @pulumi.getter(name="extraPerformanceIops")
    def extra_performance_iops(self) -> builtins.int:
        """
        通过此参数可配置云盘额外性能包IOPS性能大小，仅ESSD FlexPL支持。参数   - N：表示云盘的序号，序号为“1”表示系统盘，序号为“2”或大于“2”表示数据盘，仅数据盘支持额外性能包，取值：2～16。ExtraPerformanceIOPS 表示第N个云盘的额外性能包IOPS大小：IOPS: 1-50000。Balance: 1-50000。
        """
        return pulumi.get(self, "extra_performance_iops")

    @property
    @pulumi.getter(name="extraPerformanceThroughputMb")
    def extra_performance_throughput_mb(self) -> builtins.int:
        """
        通过此参数可配置云盘额外性能包吞吐性能大小，单位MB/s，仅ESSD FlexPL支持。参数   - N：表示云盘的序号，序号为“1”表示系统盘，序号为“2”或大于“2”表示数据盘，仅数据盘支持额外性能包，取值：2～16。ExtraPerformanceThroughputMB 表示第N个云盘的额外性能包吞吐大小：Throughput：1-650。
        """
        return pulumi.get(self, "extra_performance_throughput_mb")

    @property
    @pulumi.getter(name="extraPerformanceTypeId")
    def extra_performance_type_id(self) -> builtins.str:
        """
        通过此参数可为云盘购买额外性能，仅ESSD FlexPL支持。参数   - N：表示云盘的序号，序号为“1”表示系统盘，序号为“2”或大于“2”表示数据盘，仅数据盘支持额外性能包。取值：2～16。ExtraPerformanceTypeId 表示第N个云盘的额外性能包类型：IOPS:IOPS型，使用ExtraPerformanceIOPS参数。Balance: 均衡型，使用ExtraPerformanceIOPS参数。Throughput：吞吐量型，使用ExtraPerformanceThroughputMB参数。
        """
        return pulumi.get(self, "extra_performance_type_id")

    @property
    @pulumi.getter
    def size(self) -> builtins.int:
        """
        云盘的容量，单位为GiB。系统盘取值范围：10   - 500。数据盘取值范围：10   - 8192。如果是 ESSD_FlexPL 并使用额外性能，大小必须 >= 500 GB。
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> builtins.str:
        """
        云盘的类型：ESSD*FlexPL：极速型SSDFlexPL。ESSD*PL0：极速型SSD PL0。
        """
        return pulumi.get(self, "volume_type")


@pulumi.output_type
class GetScalingGroupInstancesDistributionResult(dict):
    def __init__(__self__, *,
                 compensate_with_on_demand: builtins.bool,
                 on_demand_base_capacity: builtins.int,
                 on_demand_percentage_above_base_capacity: builtins.int,
                 spot_instance_remedy: builtins.bool):
        """
        :param builtins.bool compensate_with_on_demand: 当因价格、库存等原因无法创建足够的抢占式实例时，是否允许使用按量实例补充抢占式容量。true: 允许。false（默认）: 不允许。
        :param builtins.int on_demand_base_capacity: 伸缩组中按量计费实例个数的最小值，取值范围：0~2000。当组中按量计费实例个数少于该值时，将优先创建按量计费的实例。
        :param builtins.int on_demand_percentage_above_base_capacity: 伸缩组满足最小按量实例数要求后，超出的实例中按量实例应占的比例，取值范围：0～100。
        :param builtins.bool spot_instance_remedy: 是否允许抢占式实例到期替换。开启则表示在抢占式实例被回收前5分钟左右，伸缩组将主动新建新的抢占式实例替换掉当前抢占式实例。true: 允许。false（默认）: 不允许。
        """
        pulumi.set(__self__, "compensate_with_on_demand", compensate_with_on_demand)
        pulumi.set(__self__, "on_demand_base_capacity", on_demand_base_capacity)
        pulumi.set(__self__, "on_demand_percentage_above_base_capacity", on_demand_percentage_above_base_capacity)
        pulumi.set(__self__, "spot_instance_remedy", spot_instance_remedy)

    @property
    @pulumi.getter(name="compensateWithOnDemand")
    def compensate_with_on_demand(self) -> builtins.bool:
        """
        当因价格、库存等原因无法创建足够的抢占式实例时，是否允许使用按量实例补充抢占式容量。true: 允许。false（默认）: 不允许。
        """
        return pulumi.get(self, "compensate_with_on_demand")

    @property
    @pulumi.getter(name="onDemandBaseCapacity")
    def on_demand_base_capacity(self) -> builtins.int:
        """
        伸缩组中按量计费实例个数的最小值，取值范围：0~2000。当组中按量计费实例个数少于该值时，将优先创建按量计费的实例。
        """
        return pulumi.get(self, "on_demand_base_capacity")

    @property
    @pulumi.getter(name="onDemandPercentageAboveBaseCapacity")
    def on_demand_percentage_above_base_capacity(self) -> builtins.int:
        """
        伸缩组满足最小按量实例数要求后，超出的实例中按量实例应占的比例，取值范围：0～100。
        """
        return pulumi.get(self, "on_demand_percentage_above_base_capacity")

    @property
    @pulumi.getter(name="spotInstanceRemedy")
    def spot_instance_remedy(self) -> builtins.bool:
        """
        是否允许抢占式实例到期替换。开启则表示在抢占式实例被回收前5分钟左右，伸缩组将主动新建新的抢占式实例替换掉当前抢占式实例。true: 允许。false（默认）: 不允许。
        """
        return pulumi.get(self, "spot_instance_remedy")


@pulumi.output_type
class GetScalingGroupLaunchTemplateOverrideResult(dict):
    def __init__(__self__, *,
                 instance_type: builtins.str,
                 price_limit: builtins.float,
                 weighted_capacity: builtins.int):
        """
        :param builtins.str instance_type: 指定实例规格。本参数仅当LaunchTemplateId参数存在取值时生有效。
        :param builtins.float price_limit: 指定抢占式实例规格每小时的最高价格。本参数仅当LaunchTemplateId参数存在取值，且启动模版的计费模式为设置出价上限的抢占式实例（即SpotWithPriceLimit）时有效。
        :param builtins.int weighted_capacity: 实例规格的权重。
        """
        pulumi.set(__self__, "instance_type", instance_type)
        pulumi.set(__self__, "price_limit", price_limit)
        pulumi.set(__self__, "weighted_capacity", weighted_capacity)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> builtins.str:
        """
        指定实例规格。本参数仅当LaunchTemplateId参数存在取值时生有效。
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="priceLimit")
    def price_limit(self) -> builtins.float:
        """
        指定抢占式实例规格每小时的最高价格。本参数仅当LaunchTemplateId参数存在取值，且启动模版的计费模式为设置出价上限的抢占式实例（即SpotWithPriceLimit）时有效。
        """
        return pulumi.get(self, "price_limit")

    @property
    @pulumi.getter(name="weightedCapacity")
    def weighted_capacity(self) -> builtins.int:
        """
        实例规格的权重。
        """
        return pulumi.get(self, "weighted_capacity")


@pulumi.output_type
class GetScalingGroupServerGroupAttributeResult(dict):
    def __init__(__self__, *,
                 load_balancer_id: builtins.str,
                 port: builtins.int,
                 server_group_id: builtins.str,
                 type: builtins.str,
                 weight: builtins.int):
        """
        :param builtins.str load_balancer_id: 负载均衡实例的ID。
        :param builtins.int port: 负载均衡后端服务器组中服务器的端口号。取值1 ～ 65535。
        :param builtins.str server_group_id: 负载均衡后端服务器组的ID。
        :param builtins.str type: 负载均衡服务器组类型。单个CLB/ALB最多支持添加20个后端服务器组，所有CLB/ALB最多支持添加100个后端服务器。ALB：应用型负载均衡。CLB：传统型型负载均衡（默认）。
        :param builtins.int weight: 负载均衡后端服务器组中服务器的权重。
        """
        pulumi.set(__self__, "load_balancer_id", load_balancer_id)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "server_group_id", server_group_id)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="loadBalancerId")
    def load_balancer_id(self) -> builtins.str:
        """
        负载均衡实例的ID。
        """
        return pulumi.get(self, "load_balancer_id")

    @property
    @pulumi.getter
    def port(self) -> builtins.int:
        """
        负载均衡后端服务器组中服务器的端口号。取值1 ～ 65535。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="serverGroupId")
    def server_group_id(self) -> builtins.str:
        """
        负载均衡后端服务器组的ID。
        """
        return pulumi.get(self, "server_group_id")

    @property
    @pulumi.getter
    def type(self) -> builtins.str:
        """
        负载均衡服务器组类型。单个CLB/ALB最多支持添加20个后端服务器组，所有CLB/ALB最多支持添加100个后端服务器。ALB：应用型负载均衡。CLB：传统型型负载均衡（默认）。
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def weight(self) -> builtins.int:
        """
        负载均衡后端服务器组中服务器的权重。
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class GetScalingGroupTagResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 value: builtins.str):
        """
        :param builtins.str key: 用户标签的标签键。
        :param builtins.str value: 用户标签的标签值。
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        用户标签的标签键。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        """
        用户标签的标签值。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetScalingPolicyAlarmPolicyResult(dict):
    def __init__(__self__, *,
                 condition: 'outputs.GetScalingPolicyAlarmPolicyConditionResult',
                 condition_operator: builtins.str,
                 conditions: Sequence['outputs.GetScalingPolicyAlarmPolicyConditionResult'],
                 effective: builtins.str,
                 evaluation_count: builtins.int,
                 rule_type: builtins.str):
        """
        :param 'GetScalingPolicyAlarmPolicyConditionArgs' condition: 单指标监控时的监控指标详细信息。仅当ScalingPolicyType取值为Alarm时有效。
        :param builtins.str condition_operator: 多指标告警时的判定条件。&&：多个指标同时成立才判定为触发告警。||（默认）：任意指标满足条件就判定为触发告警。
        :param Sequence['GetScalingPolicyAlarmPolicyConditionArgs'] conditions: 多指标监控时的监控指标详细信息。仅当ScalingPolicyType取值为Alarm时有效，且必须配置AlarmPolicy.Condition.x或AlarmPolicy.Conditions.x相关参数，当二者同时配置时，仅AlarmPolicy.Conditions.x生效。
        :param builtins.str effective: 报警任务的生效时间段。
        :param builtins.int evaluation_count: 当监控指标数据连续几次达到阈值时，即触发伸缩行为。仅当ScalingPolicyType取值为Alarm时有效且为必填项。
        :param builtins.str rule_type: 报警任务的类型，取值：Static：表示由agent采集的静态监控。仅当ScalingPolicyType取值为Alarm时有效且为必填项。
        """
        pulumi.set(__self__, "condition", condition)
        pulumi.set(__self__, "condition_operator", condition_operator)
        pulumi.set(__self__, "conditions", conditions)
        pulumi.set(__self__, "effective", effective)
        pulumi.set(__self__, "evaluation_count", evaluation_count)
        pulumi.set(__self__, "rule_type", rule_type)

    @property
    @pulumi.getter
    def condition(self) -> 'outputs.GetScalingPolicyAlarmPolicyConditionResult':
        """
        单指标监控时的监控指标详细信息。仅当ScalingPolicyType取值为Alarm时有效。
        """
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter(name="conditionOperator")
    def condition_operator(self) -> builtins.str:
        """
        多指标告警时的判定条件。&&：多个指标同时成立才判定为触发告警。||（默认）：任意指标满足条件就判定为触发告警。
        """
        return pulumi.get(self, "condition_operator")

    @property
    @pulumi.getter
    def conditions(self) -> Sequence['outputs.GetScalingPolicyAlarmPolicyConditionResult']:
        """
        多指标监控时的监控指标详细信息。仅当ScalingPolicyType取值为Alarm时有效，且必须配置AlarmPolicy.Condition.x或AlarmPolicy.Conditions.x相关参数，当二者同时配置时，仅AlarmPolicy.Conditions.x生效。
        """
        return pulumi.get(self, "conditions")

    @property
    @pulumi.getter
    def effective(self) -> builtins.str:
        """
        报警任务的生效时间段。
        """
        return pulumi.get(self, "effective")

    @property
    @pulumi.getter(name="evaluationCount")
    def evaluation_count(self) -> builtins.int:
        """
        当监控指标数据连续几次达到阈值时，即触发伸缩行为。仅当ScalingPolicyType取值为Alarm时有效且为必填项。
        """
        return pulumi.get(self, "evaluation_count")

    @property
    @pulumi.getter(name="ruleType")
    def rule_type(self) -> builtins.str:
        """
        报警任务的类型，取值：Static：表示由agent采集的静态监控。仅当ScalingPolicyType取值为Alarm时有效且为必填项。
        """
        return pulumi.get(self, "rule_type")


@pulumi.output_type
class GetScalingPolicyAlarmPolicyConditionResult(dict):
    def __init__(__self__, *,
                 comparison_operator: builtins.str,
                 metric_name: builtins.str,
                 metric_unit: builtins.str,
                 threshold: builtins.str):
        """
        :param builtins.str comparison_operator: 指标告警时的规则表达式对象。>：大于。<：小于。=：等于。
        :param builtins.str metric_name: 指标告警时的监控指标名称。CpuTotal*Max：带内CPU使用率最大值。CpuTotal*Min：带内CPU使用率最小值。CpuTotal*Avg：带内CPU使用率平均值。MemoryUsedUtilization*Max：带内内存使用率最大值。MemoryUsedUtilization*Min：带内内存使用率最小值。MemoryUsedUtilization*Avg：带内内存使用率平均值。Instance*CpuBusy*Max：带外CPU利用率最大值。Instance*CpuBusy*Min：带外CPU利用率最小值。Instance*CpuBusy*Avg：带外CPU利用率平均值。Instance*NetTxBits*Avg: 带外网络流出速率平均值。Instance*NetRxBits*Avg: 带外网络流入速率平均值。Instance*NetTxPackets*Avg: 带外网络发送包速率平均值。Instance*NetRxPackets*Avg: 带外网络接收包速率平均值。SystemDiskReadBytes*Avg: 带内系统盘读带宽平均值。SystemDiskWriteBytes*Avg: 带内系统盘写带宽平均值。SystemDiskReadIOPS*Avg: 带内系统盘读IOPS平均值。SystemDiskWriteIOPS*Avg: 带内系统盘写IOPS平均值。NetTcpConnection_Avg: 带内TCP连接数平均值。
        :param builtins.str metric_unit: 指标告警时的监控指标阈值的单位。当AlarmPolicy.Conditions.MetricName参数取值为CPU/内存使用率时: Percent。当AlarmPolicy.Conditions.MetricName参数取值为系统盘读/写带宽时: Bytes/Second(IEC)。当AlarmPolicy.Conditions.MetricName参数取值为系统盘读/写IOPS时: Count/Second。当AlarmPolicy.Conditions.MetricName参数取值为TCP连接数时: Count。当AlarmPolicy.Condition.MetricName参数取值为网络流入/流出速率时: Bits/Second(IEC)。当AlarmPolicy.Condition.MetricName参数取值为网络收发包速率时: Packet/Second。
        :param builtins.str threshold: 指标告警时的监控指标的阈值。当AlarmPolicy.Conditions.MetricUnit取值为Percent时：1 ～ 100。当AlarmPolicy.Conditions.MetricUnit取值为Bytes/Second(IEC)时：大于0的整数。当AlarmPolicy.Conditions.MetricUnit取值为Count/Second时：大于0的整数。当AlarmPolicy.Conditions.MetricUnit取值为Count时：大于0的整数。当AlarmPolicy.Condition.MetricUnit取值为Bits/Second(IEC)时：大于0的整数。当AlarmPolicy.Condition.MetricUnit取值为Packet/Second时：大于0的整数。
        """
        pulumi.set(__self__, "comparison_operator", comparison_operator)
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "metric_unit", metric_unit)
        pulumi.set(__self__, "threshold", threshold)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> builtins.str:
        """
        指标告警时的规则表达式对象。>：大于。<：小于。=：等于。
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> builtins.str:
        """
        指标告警时的监控指标名称。CpuTotal*Max：带内CPU使用率最大值。CpuTotal*Min：带内CPU使用率最小值。CpuTotal*Avg：带内CPU使用率平均值。MemoryUsedUtilization*Max：带内内存使用率最大值。MemoryUsedUtilization*Min：带内内存使用率最小值。MemoryUsedUtilization*Avg：带内内存使用率平均值。Instance*CpuBusy*Max：带外CPU利用率最大值。Instance*CpuBusy*Min：带外CPU利用率最小值。Instance*CpuBusy*Avg：带外CPU利用率平均值。Instance*NetTxBits*Avg: 带外网络流出速率平均值。Instance*NetRxBits*Avg: 带外网络流入速率平均值。Instance*NetTxPackets*Avg: 带外网络发送包速率平均值。Instance*NetRxPackets*Avg: 带外网络接收包速率平均值。SystemDiskReadBytes*Avg: 带内系统盘读带宽平均值。SystemDiskWriteBytes*Avg: 带内系统盘写带宽平均值。SystemDiskReadIOPS*Avg: 带内系统盘读IOPS平均值。SystemDiskWriteIOPS*Avg: 带内系统盘写IOPS平均值。NetTcpConnection_Avg: 带内TCP连接数平均值。
        """
        return pulumi.get(self, "metric_name")

    @property
    @pulumi.getter(name="metricUnit")
    def metric_unit(self) -> builtins.str:
        """
        指标告警时的监控指标阈值的单位。当AlarmPolicy.Conditions.MetricName参数取值为CPU/内存使用率时: Percent。当AlarmPolicy.Conditions.MetricName参数取值为系统盘读/写带宽时: Bytes/Second(IEC)。当AlarmPolicy.Conditions.MetricName参数取值为系统盘读/写IOPS时: Count/Second。当AlarmPolicy.Conditions.MetricName参数取值为TCP连接数时: Count。当AlarmPolicy.Condition.MetricName参数取值为网络流入/流出速率时: Bits/Second(IEC)。当AlarmPolicy.Condition.MetricName参数取值为网络收发包速率时: Packet/Second。
        """
        return pulumi.get(self, "metric_unit")

    @property
    @pulumi.getter
    def threshold(self) -> builtins.str:
        """
        指标告警时的监控指标的阈值。当AlarmPolicy.Conditions.MetricUnit取值为Percent时：1 ～ 100。当AlarmPolicy.Conditions.MetricUnit取值为Bytes/Second(IEC)时：大于0的整数。当AlarmPolicy.Conditions.MetricUnit取值为Count/Second时：大于0的整数。当AlarmPolicy.Conditions.MetricUnit取值为Count时：大于0的整数。当AlarmPolicy.Condition.MetricUnit取值为Bits/Second(IEC)时：大于0的整数。当AlarmPolicy.Condition.MetricUnit取值为Packet/Second时：大于0的整数。
        """
        return pulumi.get(self, "threshold")


@pulumi.output_type
class GetScalingPolicyScheduledPolicyResult(dict):
    def __init__(__self__, *,
                 launch_time: builtins.str,
                 launch_time_read: builtins.str,
                 recurrence_end_time: builtins.str,
                 recurrence_end_time_read: builtins.str,
                 recurrence_start_time: builtins.str,
                 recurrence_type: builtins.str,
                 recurrence_value: builtins.str):
        """
        :param builtins.str launch_time: 表示任务的触发时间，默认为此刻。当ScalingPolicyType值为Scheduled时，表示定时任务的触发时间。当ScalingPolicyType值为Recurrence时：如果ScheduledPolicy.RecurrenceType为空，则表示仅按照此处指定的日期和时间执行一次。如果ScheduledPolicy.RecurrenceType不为空，则表示周期任务开始时间。
        :param builtins.str launch_time_read: 表示任务的触发时间。只读字段，修改或创建使用LaunchTime。
        :param builtins.str recurrence_end_time: 表示周期任务的结束时间。仅支持选择自创建当日起365日内的时间。若不配置，则根据重复周期（ScheduledPolicy.RecurrenceType）默认为此刻后的一天/周/月。设置为空，表示本任务永不停止。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        :param builtins.str recurrence_end_time_read: 表示周期任务的结束时间。只读字段，修改或创建使用RecurrenceEndTime。
        :param builtins.str recurrence_start_time: 表示周期任务的开始执行时间。当ScalingPolicyType取值为Recurrence时有效。
        :param builtins.str recurrence_type: 表示周期任务的重复周期，取值：Daily：每XX天执行一次。Weekly：选择每周中的几天，每天执行一次。Monthly：选择每月中XX号到XX号，每天执行一次。Cron：按照指定的Cron表达式执行。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        :param builtins.str recurrence_value: 表示重复执行周期任务的数值。当ScheduledPolicy.RecurrenceType参数取值为Daily时，只能填写一个值，取值：1   - 31。当ScheduledPolicy.RecurrenceType参数取值为Weekly时，可以填入多个值，使用英文逗号（,）分隔。星期一到星期日的取值依次为：1,2,3,4,5,6,7。当ScheduledPolicy.RecurrenceType参数取值为Monthly时，格式为A-B。A、B的取值范围均为1-31，且B必须大于等于A。当ScheduledPolicy.RecurrenceType参数取值为Cron 时，表示UTC+8时间，支持分、时、日、月、星期的5域表达式，支持通配符英文逗号（,）、英文问号（?）、连词符（-）、星号（*）、井号（#）、斜线（/）、L和W。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        """
        pulumi.set(__self__, "launch_time", launch_time)
        pulumi.set(__self__, "launch_time_read", launch_time_read)
        pulumi.set(__self__, "recurrence_end_time", recurrence_end_time)
        pulumi.set(__self__, "recurrence_end_time_read", recurrence_end_time_read)
        pulumi.set(__self__, "recurrence_start_time", recurrence_start_time)
        pulumi.set(__self__, "recurrence_type", recurrence_type)
        pulumi.set(__self__, "recurrence_value", recurrence_value)

    @property
    @pulumi.getter(name="launchTime")
    def launch_time(self) -> builtins.str:
        """
        表示任务的触发时间，默认为此刻。当ScalingPolicyType值为Scheduled时，表示定时任务的触发时间。当ScalingPolicyType值为Recurrence时：如果ScheduledPolicy.RecurrenceType为空，则表示仅按照此处指定的日期和时间执行一次。如果ScheduledPolicy.RecurrenceType不为空，则表示周期任务开始时间。
        """
        return pulumi.get(self, "launch_time")

    @property
    @pulumi.getter(name="launchTimeRead")
    def launch_time_read(self) -> builtins.str:
        """
        表示任务的触发时间。只读字段，修改或创建使用LaunchTime。
        """
        return pulumi.get(self, "launch_time_read")

    @property
    @pulumi.getter(name="recurrenceEndTime")
    def recurrence_end_time(self) -> builtins.str:
        """
        表示周期任务的结束时间。仅支持选择自创建当日起365日内的时间。若不配置，则根据重复周期（ScheduledPolicy.RecurrenceType）默认为此刻后的一天/周/月。设置为空，表示本任务永不停止。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        """
        return pulumi.get(self, "recurrence_end_time")

    @property
    @pulumi.getter(name="recurrenceEndTimeRead")
    def recurrence_end_time_read(self) -> builtins.str:
        """
        表示周期任务的结束时间。只读字段，修改或创建使用RecurrenceEndTime。
        """
        return pulumi.get(self, "recurrence_end_time_read")

    @property
    @pulumi.getter(name="recurrenceStartTime")
    def recurrence_start_time(self) -> builtins.str:
        """
        表示周期任务的开始执行时间。当ScalingPolicyType取值为Recurrence时有效。
        """
        return pulumi.get(self, "recurrence_start_time")

    @property
    @pulumi.getter(name="recurrenceType")
    def recurrence_type(self) -> builtins.str:
        """
        表示周期任务的重复周期，取值：Daily：每XX天执行一次。Weekly：选择每周中的几天，每天执行一次。Monthly：选择每月中XX号到XX号，每天执行一次。Cron：按照指定的Cron表达式执行。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        """
        return pulumi.get(self, "recurrence_type")

    @property
    @pulumi.getter(name="recurrenceValue")
    def recurrence_value(self) -> builtins.str:
        """
        表示重复执行周期任务的数值。当ScheduledPolicy.RecurrenceType参数取值为Daily时，只能填写一个值，取值：1   - 31。当ScheduledPolicy.RecurrenceType参数取值为Weekly时，可以填入多个值，使用英文逗号（,）分隔。星期一到星期日的取值依次为：1,2,3,4,5,6,7。当ScheduledPolicy.RecurrenceType参数取值为Monthly时，格式为A-B。A、B的取值范围均为1-31，且B必须大于等于A。当ScheduledPolicy.RecurrenceType参数取值为Cron 时，表示UTC+8时间，支持分、时、日、月、星期的5域表达式，支持通配符英文逗号（,）、英文问号（?）、连词符（-）、星号（*）、井号（#）、斜线（/）、L和W。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        """
        return pulumi.get(self, "recurrence_value")


