# 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

__all__ = [
    'ScalingConfigurationEipArgs',
    'ScalingConfigurationEipArgsDict',
    'ScalingConfigurationInstanceTypeOverrideArgs',
    'ScalingConfigurationInstanceTypeOverrideArgsDict',
    'ScalingConfigurationTagArgs',
    'ScalingConfigurationTagArgsDict',
    'ScalingConfigurationVolumeArgs',
    'ScalingConfigurationVolumeArgsDict',
    'ScalingGroupInstancesDistributionArgs',
    'ScalingGroupInstancesDistributionArgsDict',
    'ScalingGroupLaunchTemplateOverrideArgs',
    'ScalingGroupLaunchTemplateOverrideArgsDict',
    'ScalingGroupServerGroupAttributeArgs',
    'ScalingGroupServerGroupAttributeArgsDict',
    'ScalingGroupTagArgs',
    'ScalingGroupTagArgsDict',
    'ScalingPolicyAlarmPolicyArgs',
    'ScalingPolicyAlarmPolicyArgsDict',
    'ScalingPolicyAlarmPolicyConditionArgs',
    'ScalingPolicyAlarmPolicyConditionArgsDict',
    'ScalingPolicyScheduledPolicyArgs',
    'ScalingPolicyScheduledPolicyArgsDict',
]

MYPY = False

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

@pulumi.input_type
class ScalingConfigurationEipArgs:
    def __init__(__self__, *,
                 bandwidth: Optional[pulumi.Input[builtins.int]] = None,
                 bandwidth_package_id: Optional[pulumi.Input[builtins.str]] = None,
                 billing_type: Optional[pulumi.Input[builtins.str]] = None,
                 isp: Optional[pulumi.Input[builtins.str]] = None,
                 release_with_instance: Optional[pulumi.Input[builtins.bool]] = None):
        """
        :param pulumi.Input[builtins.int] bandwidth: 公网IP的带宽峰值，默认为1，单位：Mbps。取值：当Eip.BillingType取值为PostPaidByBandwidth时，取值为1 ～ 500。当Eip.BillingType取值为PostPaidByTraffic时，取值为1 ～ 200。
        :param pulumi.Input[builtins.str] bandwidth_package_id: 共享带宽包的ID，表示将公网IP加入到共享带宽包。 您可以调用 DescribeBandwidthPackages 接口，查询共享带宽包的ID。 公网IP加入到共享带宽包必须同时满足如下条件：二者的安全防护类型相同。二者的线路类型相同。共享带宽包为IPv4类型。
        :param pulumi.Input[builtins.str] billing_type: 公网IP的计费类型，取值：PostPaidByBandwidth（默认）：按量计费-按带宽上限计费。PostPaidByTraffic：按量计费-按实际流量计费。
        :param pulumi.Input[builtins.str] isp: 线路类型，取值：BGP（默认）：BGP线路。若您的账号已申请使用静态单线，ISP还可以传入ChinaMobile（表示中国移动）、ChinaTelecom（表示中国电信）、ChinaUnicom（表示中国联通）。
        :param pulumi.Input[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[pulumi.Input[builtins.int]]:
        """
        公网IP的带宽峰值，默认为1，单位：Mbps。取值：当Eip.BillingType取值为PostPaidByBandwidth时，取值为1 ～ 500。当Eip.BillingType取值为PostPaidByTraffic时，取值为1 ～ 200。
        """
        return pulumi.get(self, "bandwidth")

    @bandwidth.setter
    def bandwidth(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "bandwidth", value)

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

    @bandwidth_package_id.setter
    def bandwidth_package_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "bandwidth_package_id", value)

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

    @billing_type.setter
    def billing_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "billing_type", value)

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

    @isp.setter
    def isp(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "isp", value)

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

    @release_with_instance.setter
    def release_with_instance(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "release_with_instance", value)


if not MYPY:
    class ScalingConfigurationInstanceTypeOverrideArgsDict(TypedDict):
        instance_type: NotRequired[pulumi.Input[builtins.str]]
        """
        指定抢占式实例的规格。参数   - N：表示实例规格的序号，取值为1 ～ 10。取值   - InstanceType：表示抢占式实例的规格。多个规格之间用&分隔。
        """
        price_limit: NotRequired[pulumi.Input[builtins.float]]
        """
        指定抢占式实例规格每小时的最高价格参数   - N：表示实例规格的序号，取值为1 ～ 10。取值   - PriceLimit：表示抢占式实例规格每小时的最高价格。取值：大于0，且最大不超过3位小数。多个价格之间用&分隔。
        """
elif False:
    ScalingConfigurationInstanceTypeOverrideArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingConfigurationInstanceTypeOverrideArgs:
    def __init__(__self__, *,
                 instance_type: Optional[pulumi.Input[builtins.str]] = None,
                 price_limit: Optional[pulumi.Input[builtins.float]] = None):
        """
        :param pulumi.Input[builtins.str] instance_type: 指定抢占式实例的规格。参数   - N：表示实例规格的序号，取值为1 ～ 10。取值   - InstanceType：表示抢占式实例的规格。多个规格之间用&分隔。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        指定抢占式实例的规格。参数   - N：表示实例规格的序号，取值为1 ～ 10。取值   - InstanceType：表示抢占式实例的规格。多个规格之间用&分隔。
        """
        return pulumi.get(self, "instance_type")

    @instance_type.setter
    def instance_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "instance_type", value)

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

    @price_limit.setter
    def price_limit(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "price_limit", value)


if not MYPY:
    class ScalingConfigurationTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        标签键。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        标签值。
        """
elif False:
    ScalingConfigurationTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingConfigurationTagArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] key: 标签键。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        标签键。
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "value", value)


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

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

    @delete_with_instance.setter
    def delete_with_instance(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "delete_with_instance", value)

    @property
    @pulumi.getter(name="extraPerformanceIops")
    def extra_performance_iops(self) -> Optional[pulumi.Input[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")

    @extra_performance_iops.setter
    def extra_performance_iops(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "extra_performance_iops", value)

    @property
    @pulumi.getter(name="extraPerformanceThroughputMb")
    def extra_performance_throughput_mb(self) -> Optional[pulumi.Input[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")

    @extra_performance_throughput_mb.setter
    def extra_performance_throughput_mb(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "extra_performance_throughput_mb", value)

    @property
    @pulumi.getter(name="extraPerformanceTypeId")
    def extra_performance_type_id(self) -> Optional[pulumi.Input[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")

    @extra_performance_type_id.setter
    def extra_performance_type_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "extra_performance_type_id", value)

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

    @size.setter
    def size(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "size", value)

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

    @volume_type.setter
    def volume_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "volume_type", value)


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

@pulumi.input_type
class ScalingGroupInstancesDistributionArgs:
    def __init__(__self__, *,
                 compensate_with_on_demand: Optional[pulumi.Input[builtins.bool]] = None,
                 on_demand_base_capacity: Optional[pulumi.Input[builtins.int]] = None,
                 on_demand_percentage_above_base_capacity: Optional[pulumi.Input[builtins.int]] = None,
                 spot_instance_remedy: Optional[pulumi.Input[builtins.bool]] = None):
        """
        :param pulumi.Input[builtins.bool] compensate_with_on_demand: 当因价格、库存等原因无法创建足够的抢占式实例时，是否允许使用按量实例补充抢占式容量。true: 允许。false（默认）: 不允许。
        :param pulumi.Input[builtins.int] on_demand_base_capacity: 伸缩组中按量计费实例个数的最小值，取值范围：0~2000。当组中按量计费实例个数少于该值时，将优先创建按量计费的实例。
        :param pulumi.Input[builtins.int] on_demand_percentage_above_base_capacity: 伸缩组满足最小按量实例数要求后，超出的实例中按量实例应占的比例，取值范围：0～100。
        :param pulumi.Input[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[pulumi.Input[builtins.bool]]:
        """
        当因价格、库存等原因无法创建足够的抢占式实例时，是否允许使用按量实例补充抢占式容量。true: 允许。false（默认）: 不允许。
        """
        return pulumi.get(self, "compensate_with_on_demand")

    @compensate_with_on_demand.setter
    def compensate_with_on_demand(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "compensate_with_on_demand", value)

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

    @on_demand_base_capacity.setter
    def on_demand_base_capacity(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "on_demand_base_capacity", value)

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

    @on_demand_percentage_above_base_capacity.setter
    def on_demand_percentage_above_base_capacity(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "on_demand_percentage_above_base_capacity", value)

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

    @spot_instance_remedy.setter
    def spot_instance_remedy(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "spot_instance_remedy", value)


if not MYPY:
    class ScalingGroupLaunchTemplateOverrideArgsDict(TypedDict):
        instance_type: NotRequired[pulumi.Input[builtins.str]]
        """
        指定实例规格。本参数仅当LaunchTemplateId参数存在取值时生有效。
        """
        price_limit: NotRequired[pulumi.Input[builtins.float]]
        """
        指定抢占式实例规格每小时的最高价格。本参数仅当LaunchTemplateId参数存在取值，且启动模版的计费模式为设置出价上限的抢占式实例（即SpotWithPriceLimit）时有效。
        """
elif False:
    ScalingGroupLaunchTemplateOverrideArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingGroupLaunchTemplateOverrideArgs:
    def __init__(__self__, *,
                 instance_type: Optional[pulumi.Input[builtins.str]] = None,
                 price_limit: Optional[pulumi.Input[builtins.float]] = None):
        """
        :param pulumi.Input[builtins.str] instance_type: 指定实例规格。本参数仅当LaunchTemplateId参数存在取值时生有效。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        指定实例规格。本参数仅当LaunchTemplateId参数存在取值时生有效。
        """
        return pulumi.get(self, "instance_type")

    @instance_type.setter
    def instance_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "instance_type", value)

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

    @price_limit.setter
    def price_limit(self, value: Optional[pulumi.Input[builtins.float]]):
        pulumi.set(self, "price_limit", value)


if not MYPY:
    class ScalingGroupServerGroupAttributeArgsDict(TypedDict):
        port: NotRequired[pulumi.Input[builtins.int]]
        """
        负载均衡后端服务器组中服务器的端口号。取值1 ～ 65535。
        """
        server_group_id: NotRequired[pulumi.Input[builtins.str]]
        """
        负载均衡后端服务器组的ID。
        """
        type: NotRequired[pulumi.Input[builtins.str]]
        """
        负载均衡服务器组类型。单个CLB/ALB最多支持添加20个后端服务器组，所有CLB/ALB最多支持添加100个后端服务器。ALB：应用型负载均衡。CLB：传统型型负载均衡（默认）。
        """
        weight: NotRequired[pulumi.Input[builtins.int]]
        """
        负载均衡后端服务器组中服务器的权重。
        """
elif False:
    ScalingGroupServerGroupAttributeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingGroupServerGroupAttributeArgs:
    def __init__(__self__, *,
                 port: Optional[pulumi.Input[builtins.int]] = None,
                 server_group_id: Optional[pulumi.Input[builtins.str]] = None,
                 type: Optional[pulumi.Input[builtins.str]] = None,
                 weight: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.int] port: 负载均衡后端服务器组中服务器的端口号。取值1 ～ 65535。
        :param pulumi.Input[builtins.str] server_group_id: 负载均衡后端服务器组的ID。
        :param pulumi.Input[builtins.str] type: 负载均衡服务器组类型。单个CLB/ALB最多支持添加20个后端服务器组，所有CLB/ALB最多支持添加100个后端服务器。ALB：应用型负载均衡。CLB：传统型型负载均衡（默认）。
        :param pulumi.Input[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[pulumi.Input[builtins.int]]:
        """
        负载均衡后端服务器组中服务器的端口号。取值1 ～ 65535。
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "port", value)

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

    @server_group_id.setter
    def server_group_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "server_group_id", value)

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

    @type.setter
    def type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "type", value)

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

    @weight.setter
    def weight(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "weight", value)


if not MYPY:
    class ScalingGroupTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        用户标签的标签键。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        用户标签的标签值。
        """
elif False:
    ScalingGroupTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingGroupTagArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] key: 用户标签的标签键。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        用户标签的标签键。
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "value", value)


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

@pulumi.input_type
class ScalingPolicyAlarmPolicyArgs:
    def __init__(__self__, *,
                 condition: Optional[pulumi.Input['ScalingPolicyAlarmPolicyConditionArgs']] = None,
                 condition_operator: Optional[pulumi.Input[builtins.str]] = None,
                 conditions: Optional[pulumi.Input[Sequence[pulumi.Input['ScalingPolicyAlarmPolicyConditionArgs']]]] = None,
                 effective: Optional[pulumi.Input[builtins.str]] = None,
                 evaluation_count: Optional[pulumi.Input[builtins.int]] = None,
                 rule_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input['ScalingPolicyAlarmPolicyConditionArgs'] condition: 单指标监控时的监控指标详细信息。仅当ScalingPolicyType取值为Alarm时有效。
        :param pulumi.Input[builtins.str] condition_operator: 多指标告警时的判定条件。&&：多个指标同时成立才判定为触发告警。||（默认）：任意指标满足条件就判定为触发告警。
        :param pulumi.Input[builtins.str] effective: 报警任务的生效时间段。
        :param pulumi.Input[builtins.int] evaluation_count: 当监控指标数据连续几次达到阈值时，即触发伸缩行为。仅当ScalingPolicyType取值为Alarm时有效且为必填项。
        :param pulumi.Input[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[pulumi.Input['ScalingPolicyAlarmPolicyConditionArgs']]:
        """
        单指标监控时的监控指标详细信息。仅当ScalingPolicyType取值为Alarm时有效。
        """
        return pulumi.get(self, "condition")

    @condition.setter
    def condition(self, value: Optional[pulumi.Input['ScalingPolicyAlarmPolicyConditionArgs']]):
        pulumi.set(self, "condition", value)

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

    @condition_operator.setter
    def condition_operator(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "condition_operator", value)

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

    @conditions.setter
    def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ScalingPolicyAlarmPolicyConditionArgs']]]]):
        pulumi.set(self, "conditions", value)

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

    @effective.setter
    def effective(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "effective", value)

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

    @evaluation_count.setter
    def evaluation_count(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "evaluation_count", value)

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

    @rule_type.setter
    def rule_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "rule_type", value)


if not MYPY:
    class ScalingPolicyAlarmPolicyConditionArgsDict(TypedDict):
        comparison_operator: NotRequired[pulumi.Input[builtins.str]]
        """
        指标告警时的规则表达式对象。>：大于。<：小于。=：等于。
        """
        metric_name: NotRequired[pulumi.Input[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连接数平均值。
        """
        metric_unit: NotRequired[pulumi.Input[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。
        """
        threshold: NotRequired[pulumi.Input[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的整数。
        """
elif False:
    ScalingPolicyAlarmPolicyConditionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingPolicyAlarmPolicyConditionArgs:
    def __init__(__self__, *,
                 comparison_operator: Optional[pulumi.Input[builtins.str]] = None,
                 metric_name: Optional[pulumi.Input[builtins.str]] = None,
                 metric_unit: Optional[pulumi.Input[builtins.str]] = None,
                 threshold: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] comparison_operator: 指标告警时的规则表达式对象。>：大于。<：小于。=：等于。
        :param pulumi.Input[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 pulumi.Input[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 pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        指标告警时的规则表达式对象。>：大于。<：小于。=：等于。
        """
        return pulumi.get(self, "comparison_operator")

    @comparison_operator.setter
    def comparison_operator(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "comparison_operator", value)

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> Optional[pulumi.Input[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")

    @metric_name.setter
    def metric_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "metric_name", value)

    @property
    @pulumi.getter(name="metricUnit")
    def metric_unit(self) -> Optional[pulumi.Input[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")

    @metric_unit.setter
    def metric_unit(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "metric_unit", value)

    @property
    @pulumi.getter
    def threshold(self) -> Optional[pulumi.Input[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")

    @threshold.setter
    def threshold(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "threshold", value)


if not MYPY:
    class ScalingPolicyScheduledPolicyArgsDict(TypedDict):
        launch_time: NotRequired[pulumi.Input[builtins.str]]
        """
        表示任务的触发时间，默认为此刻。当ScalingPolicyType值为Scheduled时，表示定时任务的触发时间。当ScalingPolicyType值为Recurrence时：如果ScheduledPolicy.RecurrenceType为空，则表示仅按照此处指定的日期和时间执行一次。如果ScheduledPolicy.RecurrenceType不为空，则表示周期任务开始时间。
        """
        launch_time_read: NotRequired[pulumi.Input[builtins.str]]
        """
        表示任务的触发时间。只读字段，修改或创建使用LaunchTime。
        """
        recurrence_end_time: NotRequired[pulumi.Input[builtins.str]]
        """
        表示周期任务的结束时间。仅支持选择自创建当日起365日内的时间。若不配置，则根据重复周期（ScheduledPolicy.RecurrenceType）默认为此刻后的一天/周/月。设置为空，表示本任务永不停止。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        """
        recurrence_end_time_read: NotRequired[pulumi.Input[builtins.str]]
        """
        表示周期任务的结束时间。只读字段，修改或创建使用RecurrenceEndTime。
        """
        recurrence_start_time: NotRequired[pulumi.Input[builtins.str]]
        """
        表示周期任务的开始执行时间。当ScalingPolicyType取值为Recurrence时有效。
        """
        recurrence_type: NotRequired[pulumi.Input[builtins.str]]
        """
        表示周期任务的重复周期，取值：Daily：每XX天执行一次。Weekly：选择每周中的几天，每天执行一次。Monthly：选择每月中XX号到XX号，每天执行一次。Cron：按照指定的Cron表达式执行。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        """
        recurrence_value: NotRequired[pulumi.Input[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时有效且为必填项。
        """
elif False:
    ScalingPolicyScheduledPolicyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingPolicyScheduledPolicyArgs:
    def __init__(__self__, *,
                 launch_time: Optional[pulumi.Input[builtins.str]] = None,
                 launch_time_read: Optional[pulumi.Input[builtins.str]] = None,
                 recurrence_end_time: Optional[pulumi.Input[builtins.str]] = None,
                 recurrence_end_time_read: Optional[pulumi.Input[builtins.str]] = None,
                 recurrence_start_time: Optional[pulumi.Input[builtins.str]] = None,
                 recurrence_type: Optional[pulumi.Input[builtins.str]] = None,
                 recurrence_value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] launch_time: 表示任务的触发时间，默认为此刻。当ScalingPolicyType值为Scheduled时，表示定时任务的触发时间。当ScalingPolicyType值为Recurrence时：如果ScheduledPolicy.RecurrenceType为空，则表示仅按照此处指定的日期和时间执行一次。如果ScheduledPolicy.RecurrenceType不为空，则表示周期任务开始时间。
        :param pulumi.Input[builtins.str] launch_time_read: 表示任务的触发时间。只读字段，修改或创建使用LaunchTime。
        :param pulumi.Input[builtins.str] recurrence_end_time: 表示周期任务的结束时间。仅支持选择自创建当日起365日内的时间。若不配置，则根据重复周期（ScheduledPolicy.RecurrenceType）默认为此刻后的一天/周/月。设置为空，表示本任务永不停止。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        :param pulumi.Input[builtins.str] recurrence_end_time_read: 表示周期任务的结束时间。只读字段，修改或创建使用RecurrenceEndTime。
        :param pulumi.Input[builtins.str] recurrence_start_time: 表示周期任务的开始执行时间。当ScalingPolicyType取值为Recurrence时有效。
        :param pulumi.Input[builtins.str] recurrence_type: 表示周期任务的重复周期，取值：Daily：每XX天执行一次。Weekly：选择每周中的几天，每天执行一次。Monthly：选择每月中XX号到XX号，每天执行一次。Cron：按照指定的Cron表达式执行。当ScalingPolicyType取值为Recurrence时有效且为必填项。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        表示任务的触发时间，默认为此刻。当ScalingPolicyType值为Scheduled时，表示定时任务的触发时间。当ScalingPolicyType值为Recurrence时：如果ScheduledPolicy.RecurrenceType为空，则表示仅按照此处指定的日期和时间执行一次。如果ScheduledPolicy.RecurrenceType不为空，则表示周期任务开始时间。
        """
        return pulumi.get(self, "launch_time")

    @launch_time.setter
    def launch_time(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "launch_time", value)

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

    @launch_time_read.setter
    def launch_time_read(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "launch_time_read", value)

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

    @recurrence_end_time.setter
    def recurrence_end_time(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "recurrence_end_time", value)

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

    @recurrence_end_time_read.setter
    def recurrence_end_time_read(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "recurrence_end_time_read", value)

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

    @recurrence_start_time.setter
    def recurrence_start_time(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "recurrence_start_time", value)

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

    @recurrence_type.setter
    def recurrence_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "recurrence_type", value)

    @property
    @pulumi.getter(name="recurrenceValue")
    def recurrence_value(self) -> Optional[pulumi.Input[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")

    @recurrence_value.setter
    def recurrence_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "recurrence_value", value)


