# 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 warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'ScalingConfigurationDataDisk',
    'ScalingGroupVServerGroupsVserverGroup',
    'ScalingGroupVServerGroupsVserverGroupVserverAttribute',
    'ScalingRuleStepAdjustment',
    'GetAlarmsAlarmResult',
    'GetLifecycleHooksHookResult',
    'GetNotificationsNotificationResult',
    'GetScalingConfigurationsConfigurationResult',
    'GetScalingConfigurationsConfigurationDataDiskResult',
    'GetScalingGroupsGroupResult',
    'GetScalingRulesRuleResult',
    'GetScheduledTasksTaskResult',
]

@pulumi.output_type
class ScalingConfigurationDataDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoSnapshotPolicyId":
            suggest = "auto_snapshot_policy_id"
        elif key == "deleteWithInstance":
            suggest = "delete_with_instance"
        elif key == "kmsKeyId":
            suggest = "kms_key_id"
        elif key == "performanceLevel":
            suggest = "performance_level"
        elif key == "snapshotId":
            suggest = "snapshot_id"

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

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

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

    def __init__(__self__, *,
                 auto_snapshot_policy_id: Optional[str] = None,
                 category: Optional[str] = None,
                 delete_with_instance: Optional[bool] = None,
                 description: Optional[str] = None,
                 device: Optional[str] = None,
                 encrypted: Optional[bool] = None,
                 kms_key_id: Optional[str] = None,
                 name: Optional[str] = None,
                 performance_level: Optional[str] = None,
                 size: Optional[int] = None,
                 snapshot_id: Optional[str] = None):
        if auto_snapshot_policy_id is not None:
            pulumi.set(__self__, "auto_snapshot_policy_id", auto_snapshot_policy_id)
        if category is not None:
            pulumi.set(__self__, "category", category)
        if delete_with_instance is not None:
            pulumi.set(__self__, "delete_with_instance", delete_with_instance)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if device is not None:
            pulumi.set(__self__, "device", device)
        if encrypted is not None:
            pulumi.set(__self__, "encrypted", encrypted)
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if performance_level is not None:
            pulumi.set(__self__, "performance_level", performance_level)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if snapshot_id is not None:
            pulumi.set(__self__, "snapshot_id", snapshot_id)

    @property
    @pulumi.getter(name="autoSnapshotPolicyId")
    def auto_snapshot_policy_id(self) -> Optional[str]:
        return pulumi.get(self, "auto_snapshot_policy_id")

    @property
    @pulumi.getter
    def category(self) -> Optional[str]:
        return pulumi.get(self, "category")

    @property
    @pulumi.getter(name="deleteWithInstance")
    def delete_with_instance(self) -> Optional[bool]:
        return pulumi.get(self, "delete_with_instance")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def device(self) -> Optional[str]:
        return pulumi.get(self, "device")

    @property
    @pulumi.getter
    def encrypted(self) -> Optional[bool]:
        return pulumi.get(self, "encrypted")

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[str]:
        return pulumi.get(self, "kms_key_id")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="performanceLevel")
    def performance_level(self) -> Optional[str]:
        return pulumi.get(self, "performance_level")

    @property
    @pulumi.getter
    def size(self) -> Optional[int]:
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="snapshotId")
    def snapshot_id(self) -> Optional[str]:
        return pulumi.get(self, "snapshot_id")


@pulumi.output_type
class ScalingGroupVServerGroupsVserverGroup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "loadbalancerId":
            suggest = "loadbalancer_id"
        elif key == "vserverAttributes":
            suggest = "vserver_attributes"

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

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

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

    def __init__(__self__, *,
                 loadbalancer_id: str,
                 vserver_attributes: Sequence['outputs.ScalingGroupVServerGroupsVserverGroupVserverAttribute']):
        pulumi.set(__self__, "loadbalancer_id", loadbalancer_id)
        pulumi.set(__self__, "vserver_attributes", vserver_attributes)

    @property
    @pulumi.getter(name="loadbalancerId")
    def loadbalancer_id(self) -> str:
        return pulumi.get(self, "loadbalancer_id")

    @property
    @pulumi.getter(name="vserverAttributes")
    def vserver_attributes(self) -> Sequence['outputs.ScalingGroupVServerGroupsVserverGroupVserverAttribute']:
        return pulumi.get(self, "vserver_attributes")


@pulumi.output_type
class ScalingGroupVServerGroupsVserverGroupVserverAttribute(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vserverGroupId":
            suggest = "vserver_group_id"

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

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

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

    def __init__(__self__, *,
                 port: int,
                 vserver_group_id: str,
                 weight: int):
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "vserver_group_id", vserver_group_id)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def port(self) -> int:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="vserverGroupId")
    def vserver_group_id(self) -> str:
        return pulumi.get(self, "vserver_group_id")

    @property
    @pulumi.getter
    def weight(self) -> int:
        return pulumi.get(self, "weight")


@pulumi.output_type
class ScalingRuleStepAdjustment(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "metricIntervalLowerBound":
            suggest = "metric_interval_lower_bound"
        elif key == "metricIntervalUpperBound":
            suggest = "metric_interval_upper_bound"
        elif key == "scalingAdjustment":
            suggest = "scaling_adjustment"

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

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

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

    def __init__(__self__, *,
                 metric_interval_lower_bound: Optional[str] = None,
                 metric_interval_upper_bound: Optional[str] = None,
                 scaling_adjustment: Optional[int] = None):
        if metric_interval_lower_bound is not None:
            pulumi.set(__self__, "metric_interval_lower_bound", metric_interval_lower_bound)
        if metric_interval_upper_bound is not None:
            pulumi.set(__self__, "metric_interval_upper_bound", metric_interval_upper_bound)
        if scaling_adjustment is not None:
            pulumi.set(__self__, "scaling_adjustment", scaling_adjustment)

    @property
    @pulumi.getter(name="metricIntervalLowerBound")
    def metric_interval_lower_bound(self) -> Optional[str]:
        return pulumi.get(self, "metric_interval_lower_bound")

    @property
    @pulumi.getter(name="metricIntervalUpperBound")
    def metric_interval_upper_bound(self) -> Optional[str]:
        return pulumi.get(self, "metric_interval_upper_bound")

    @property
    @pulumi.getter(name="scalingAdjustment")
    def scaling_adjustment(self) -> Optional[int]:
        return pulumi.get(self, "scaling_adjustment")


@pulumi.output_type
class GetAlarmsAlarmResult(dict):
    def __init__(__self__, *,
                 alarm_actions: Sequence[str],
                 cloud_monitor_group_id: int,
                 comparison_operator: str,
                 description: str,
                 dimensions: Mapping[str, Any],
                 enable: bool,
                 evaluation_count: int,
                 id: str,
                 metric_name: str,
                 metric_type: str,
                 name: str,
                 period: int,
                 scaling_group_id: str,
                 state: str,
                 statistics: str,
                 threshold: str):
        """
        :param Sequence[str] alarm_actions: The list of actions to execute when this alarm transition into an ALARM state. Each action is specified as ess scaling rule ari.
        :param int cloud_monitor_group_id: Defines the application group id defined by CMS which is assigned when you upload custom metric to CMS, only available for custom metirc.
        :param str comparison_operator: The arithmetic operation to use when comparing the specified Statistic and Threshold. The specified Statistic value is used as the first operand.
        :param str description: The description for the alarm.
        :param Mapping[str, Any] dimensions: The dimension map for the alarm's associated metric.
        :param bool enable: Whether to enable specific ess alarm.
        :param int evaluation_count: The number of times that needs to satisfies comparison condition before transition into ALARM state.
        :param str id: The id of alarm.
        :param str metric_name: The name for the alarm's associated metric. See Block_metricNames_and_dimensions below for details.
        :param str metric_type: The type for the alarm's associated metric. Supported value: system, custom. "system" means the metric data is collected by Aliyun Cloud Monitor Service(CMS), "custom" means the metric data is upload to CMS by users. Defaults to system.
        :param str name: The name for ess alarm.
        :param int period: The period in seconds over which the specified statistic is applied.
        :param str scaling_group_id: Scaling group id the alarms belong to.
        :param str state: The state of alarm task.
        :param str statistics: The statistic to apply to the alarm's associated metric.
        :param str threshold: The value against which the specified statistics is compared.
        """
        pulumi.set(__self__, "alarm_actions", alarm_actions)
        pulumi.set(__self__, "cloud_monitor_group_id", cloud_monitor_group_id)
        pulumi.set(__self__, "comparison_operator", comparison_operator)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "dimensions", dimensions)
        pulumi.set(__self__, "enable", enable)
        pulumi.set(__self__, "evaluation_count", evaluation_count)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "metric_type", metric_type)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "period", period)
        pulumi.set(__self__, "scaling_group_id", scaling_group_id)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "statistics", statistics)
        pulumi.set(__self__, "threshold", threshold)

    @property
    @pulumi.getter(name="alarmActions")
    def alarm_actions(self) -> Sequence[str]:
        """
        The list of actions to execute when this alarm transition into an ALARM state. Each action is specified as ess scaling rule ari.
        """
        return pulumi.get(self, "alarm_actions")

    @property
    @pulumi.getter(name="cloudMonitorGroupId")
    def cloud_monitor_group_id(self) -> int:
        """
        Defines the application group id defined by CMS which is assigned when you upload custom metric to CMS, only available for custom metirc.
        """
        return pulumi.get(self, "cloud_monitor_group_id")

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> str:
        """
        The arithmetic operation to use when comparing the specified Statistic and Threshold. The specified Statistic value is used as the first operand.
        """
        return pulumi.get(self, "comparison_operator")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        The description for the alarm.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def dimensions(self) -> Mapping[str, Any]:
        """
        The dimension map for the alarm's associated metric.
        """
        return pulumi.get(self, "dimensions")

    @property
    @pulumi.getter
    def enable(self) -> bool:
        """
        Whether to enable specific ess alarm.
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter(name="evaluationCount")
    def evaluation_count(self) -> int:
        """
        The number of times that needs to satisfies comparison condition before transition into ALARM state.
        """
        return pulumi.get(self, "evaluation_count")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The id of alarm.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> str:
        """
        The name for the alarm's associated metric. See Block_metricNames_and_dimensions below for details.
        """
        return pulumi.get(self, "metric_name")

    @property
    @pulumi.getter(name="metricType")
    def metric_type(self) -> str:
        """
        The type for the alarm's associated metric. Supported value: system, custom. "system" means the metric data is collected by Aliyun Cloud Monitor Service(CMS), "custom" means the metric data is upload to CMS by users. Defaults to system.
        """
        return pulumi.get(self, "metric_type")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name for ess alarm.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def period(self) -> int:
        """
        The period in seconds over which the specified statistic is applied.
        """
        return pulumi.get(self, "period")

    @property
    @pulumi.getter(name="scalingGroupId")
    def scaling_group_id(self) -> str:
        """
        Scaling group id the alarms belong to.
        """
        return pulumi.get(self, "scaling_group_id")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        The state of alarm task.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter
    def statistics(self) -> str:
        """
        The statistic to apply to the alarm's associated metric.
        """
        return pulumi.get(self, "statistics")

    @property
    @pulumi.getter
    def threshold(self) -> str:
        """
        The value against which the specified statistics is compared.
        """
        return pulumi.get(self, "threshold")


@pulumi.output_type
class GetLifecycleHooksHookResult(dict):
    def __init__(__self__, *,
                 default_result: str,
                 heartbeat_timeout: int,
                 id: str,
                 lifecycle_transition: str,
                 name: str,
                 notification_arn: str,
                 notification_metadata: str,
                 scaling_group_id: str):
        """
        :param str default_result: Defines the action the Auto Scaling group should take when the lifecycle hook timeout elapses.
        :param int heartbeat_timeout: Defines the amount of time, in seconds, that can elapse before the lifecycle hook times out. When the lifecycle hook times out, Auto Scaling performs the action defined in the default_result parameter.
        :param str id: ID of the lifecycle hook.
        :param str lifecycle_transition: Type of Scaling activity attached to lifecycle hook.
        :param str name: Name of the lifecycle hook.
        :param str notification_arn: The Arn of notification target.
        :param str notification_metadata: Additional information that you want to include when Auto Scaling sends a message to the notification target.
        :param str scaling_group_id: Scaling group id the lifecycle hooks belong to.
        """
        pulumi.set(__self__, "default_result", default_result)
        pulumi.set(__self__, "heartbeat_timeout", heartbeat_timeout)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "lifecycle_transition", lifecycle_transition)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "notification_arn", notification_arn)
        pulumi.set(__self__, "notification_metadata", notification_metadata)
        pulumi.set(__self__, "scaling_group_id", scaling_group_id)

    @property
    @pulumi.getter(name="defaultResult")
    def default_result(self) -> str:
        """
        Defines the action the Auto Scaling group should take when the lifecycle hook timeout elapses.
        """
        return pulumi.get(self, "default_result")

    @property
    @pulumi.getter(name="heartbeatTimeout")
    def heartbeat_timeout(self) -> int:
        """
        Defines the amount of time, in seconds, that can elapse before the lifecycle hook times out. When the lifecycle hook times out, Auto Scaling performs the action defined in the default_result parameter.
        """
        return pulumi.get(self, "heartbeat_timeout")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        ID of the lifecycle hook.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="lifecycleTransition")
    def lifecycle_transition(self) -> str:
        """
        Type of Scaling activity attached to lifecycle hook.
        """
        return pulumi.get(self, "lifecycle_transition")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the lifecycle hook.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="notificationArn")
    def notification_arn(self) -> str:
        """
        The Arn of notification target.
        """
        return pulumi.get(self, "notification_arn")

    @property
    @pulumi.getter(name="notificationMetadata")
    def notification_metadata(self) -> str:
        """
        Additional information that you want to include when Auto Scaling sends a message to the notification target.
        """
        return pulumi.get(self, "notification_metadata")

    @property
    @pulumi.getter(name="scalingGroupId")
    def scaling_group_id(self) -> str:
        """
        Scaling group id the lifecycle hooks belong to.
        """
        return pulumi.get(self, "scaling_group_id")


@pulumi.output_type
class GetNotificationsNotificationResult(dict):
    def __init__(__self__, *,
                 id: str,
                 notification_arn: str,
                 notification_types: Sequence[str],
                 scaling_group_id: str):
        """
        :param str id: ID of the notification.
        :param str notification_arn: The Alibaba Cloud Resource Name (ARN) for the notification object.
        :param Sequence[str] notification_types: The notification types of Auto Scaling events and resource changes.
        :param str scaling_group_id: Scaling group id the notifications belong to.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "notification_arn", notification_arn)
        pulumi.set(__self__, "notification_types", notification_types)
        pulumi.set(__self__, "scaling_group_id", scaling_group_id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        ID of the notification.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="notificationArn")
    def notification_arn(self) -> str:
        """
        The Alibaba Cloud Resource Name (ARN) for the notification object.
        """
        return pulumi.get(self, "notification_arn")

    @property
    @pulumi.getter(name="notificationTypes")
    def notification_types(self) -> Sequence[str]:
        """
        The notification types of Auto Scaling events and resource changes.
        """
        return pulumi.get(self, "notification_types")

    @property
    @pulumi.getter(name="scalingGroupId")
    def scaling_group_id(self) -> str:
        """
        Scaling group id the notifications belong to.
        """
        return pulumi.get(self, "scaling_group_id")


@pulumi.output_type
class GetScalingConfigurationsConfigurationResult(dict):
    def __init__(__self__, *,
                 creation_time: str,
                 credit_specification: str,
                 data_disks: Sequence['outputs.GetScalingConfigurationsConfigurationDataDiskResult'],
                 host_name: str,
                 id: str,
                 image_id: str,
                 instance_name: str,
                 instance_type: str,
                 internet_charge_type: str,
                 internet_max_bandwidth_in: int,
                 internet_max_bandwidth_out: int,
                 lifecycle_state: str,
                 name: str,
                 scaling_group_id: str,
                 security_group_id: str,
                 system_disk_category: str,
                 system_disk_performance_level: str,
                 system_disk_size: int):
        """
        :param str creation_time: Creation time of the scaling configuration.
        :param str credit_specification: Performance mode of the t5 burstable instance.
        :param Sequence['GetScalingConfigurationsConfigurationDataDiskArgs'] data_disks: Data disks of the scaling configuration.
        :param str host_name: (Optional,Available in 1.143.0+) Hostname of an ECS instance.
        :param str id: ID of the scaling rule.
        :param str image_id: Image ID of the scaling configuration.
        :param str instance_name: (Optional,Available in 1.143.0+) InstanceName of an ECS instance.
        :param str instance_type: Instance type of the scaling configuration.
        :param str internet_charge_type: Internet charge type of the scaling configuration.
        :param int internet_max_bandwidth_in: Internet max bandwidth in of the scaling configuration.
        :param int internet_max_bandwidth_out: Internet max bandwidth of the scaling configuration.
        :param str lifecycle_state: Lifecycle state of the scaling configuration.
        :param str name: Name of the scaling configuration.
        :param str scaling_group_id: Scaling group id the scaling configurations belong to.
        :param str security_group_id: Security group ID of the scaling configuration.
        :param str system_disk_category: System disk category of the scaling configuration.
        :param str system_disk_performance_level: The performance level of the ESSD used as the system disk.
        :param int system_disk_size: System disk size of the scaling configuration.
        """
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "credit_specification", credit_specification)
        pulumi.set(__self__, "data_disks", data_disks)
        pulumi.set(__self__, "host_name", host_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "image_id", image_id)
        pulumi.set(__self__, "instance_name", instance_name)
        pulumi.set(__self__, "instance_type", instance_type)
        pulumi.set(__self__, "internet_charge_type", internet_charge_type)
        pulumi.set(__self__, "internet_max_bandwidth_in", internet_max_bandwidth_in)
        pulumi.set(__self__, "internet_max_bandwidth_out", internet_max_bandwidth_out)
        pulumi.set(__self__, "lifecycle_state", lifecycle_state)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "scaling_group_id", scaling_group_id)
        pulumi.set(__self__, "security_group_id", security_group_id)
        pulumi.set(__self__, "system_disk_category", system_disk_category)
        pulumi.set(__self__, "system_disk_performance_level", system_disk_performance_level)
        pulumi.set(__self__, "system_disk_size", system_disk_size)

    @property
    @pulumi.getter(name="creationTime")
    def creation_time(self) -> str:
        """
        Creation time of the scaling configuration.
        """
        return pulumi.get(self, "creation_time")

    @property
    @pulumi.getter(name="creditSpecification")
    def credit_specification(self) -> str:
        """
        Performance mode of the t5 burstable instance.
        """
        return pulumi.get(self, "credit_specification")

    @property
    @pulumi.getter(name="dataDisks")
    def data_disks(self) -> Sequence['outputs.GetScalingConfigurationsConfigurationDataDiskResult']:
        """
        Data disks of the scaling configuration.
        """
        return pulumi.get(self, "data_disks")

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> str:
        """
        (Optional,Available in 1.143.0+) Hostname of an ECS instance.
        """
        return pulumi.get(self, "host_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        ID of the scaling rule.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> str:
        """
        Image ID of the scaling configuration.
        """
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="instanceName")
    def instance_name(self) -> str:
        """
        (Optional,Available in 1.143.0+) InstanceName of an ECS instance.
        """
        return pulumi.get(self, "instance_name")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> str:
        """
        Instance type of the scaling configuration.
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="internetChargeType")
    def internet_charge_type(self) -> str:
        """
        Internet charge type of the scaling configuration.
        """
        return pulumi.get(self, "internet_charge_type")

    @property
    @pulumi.getter(name="internetMaxBandwidthIn")
    def internet_max_bandwidth_in(self) -> int:
        """
        Internet max bandwidth in of the scaling configuration.
        """
        return pulumi.get(self, "internet_max_bandwidth_in")

    @property
    @pulumi.getter(name="internetMaxBandwidthOut")
    def internet_max_bandwidth_out(self) -> int:
        """
        Internet max bandwidth of the scaling configuration.
        """
        return pulumi.get(self, "internet_max_bandwidth_out")

    @property
    @pulumi.getter(name="lifecycleState")
    def lifecycle_state(self) -> str:
        """
        Lifecycle state of the scaling configuration.
        """
        return pulumi.get(self, "lifecycle_state")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the scaling configuration.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="scalingGroupId")
    def scaling_group_id(self) -> str:
        """
        Scaling group id the scaling configurations belong to.
        """
        return pulumi.get(self, "scaling_group_id")

    @property
    @pulumi.getter(name="securityGroupId")
    def security_group_id(self) -> str:
        """
        Security group ID of the scaling configuration.
        """
        return pulumi.get(self, "security_group_id")

    @property
    @pulumi.getter(name="systemDiskCategory")
    def system_disk_category(self) -> str:
        """
        System disk category of the scaling configuration.
        """
        return pulumi.get(self, "system_disk_category")

    @property
    @pulumi.getter(name="systemDiskPerformanceLevel")
    def system_disk_performance_level(self) -> str:
        """
        The performance level of the ESSD used as the system disk.
        """
        return pulumi.get(self, "system_disk_performance_level")

    @property
    @pulumi.getter(name="systemDiskSize")
    def system_disk_size(self) -> int:
        """
        System disk size of the scaling configuration.
        """
        return pulumi.get(self, "system_disk_size")


@pulumi.output_type
class GetScalingConfigurationsConfigurationDataDiskResult(dict):
    def __init__(__self__, *,
                 category: Optional[str] = None,
                 delete_with_instance: Optional[bool] = None,
                 device: Optional[str] = None,
                 performance_level: Optional[str] = None,
                 size: Optional[int] = None,
                 snapshot_id: Optional[str] = None):
        """
        :param str category: Category of data disk.
        :param bool delete_with_instance: Delete_with_instance attribute of data disk.
        :param str device: Device attribute of data disk.
        :param str performance_level: The performance level of the ESSD used as data disk.
        :param int size: Size of data disk.
        :param str snapshot_id: Size of data disk.
        """
        if category is not None:
            pulumi.set(__self__, "category", category)
        if delete_with_instance is not None:
            pulumi.set(__self__, "delete_with_instance", delete_with_instance)
        if device is not None:
            pulumi.set(__self__, "device", device)
        if performance_level is not None:
            pulumi.set(__self__, "performance_level", performance_level)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if snapshot_id is not None:
            pulumi.set(__self__, "snapshot_id", snapshot_id)

    @property
    @pulumi.getter
    def category(self) -> Optional[str]:
        """
        Category of data disk.
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter(name="deleteWithInstance")
    def delete_with_instance(self) -> Optional[bool]:
        """
        Delete_with_instance attribute of data disk.
        """
        return pulumi.get(self, "delete_with_instance")

    @property
    @pulumi.getter
    def device(self) -> Optional[str]:
        """
        Device attribute of data disk.
        """
        return pulumi.get(self, "device")

    @property
    @pulumi.getter(name="performanceLevel")
    def performance_level(self) -> Optional[str]:
        """
        The performance level of the ESSD used as data disk.
        """
        return pulumi.get(self, "performance_level")

    @property
    @pulumi.getter
    def size(self) -> Optional[int]:
        """
        Size of data disk.
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="snapshotId")
    def snapshot_id(self) -> Optional[str]:
        """
        Size of data disk.
        """
        return pulumi.get(self, "snapshot_id")


@pulumi.output_type
class GetScalingGroupsGroupResult(dict):
    def __init__(__self__, *,
                 active_capacity: int,
                 active_scaling_configuration: str,
                 cooldown_time: int,
                 creation_time: str,
                 db_instance_ids: Sequence[str],
                 id: str,
                 launch_template_id: str,
                 launch_template_version: str,
                 lifecycle_state: str,
                 load_balancer_ids: Sequence[str],
                 max_size: int,
                 min_size: int,
                 name: str,
                 pending_capacity: int,
                 region_id: str,
                 removal_policies: Sequence[str],
                 removing_capacity: int,
                 total_capacity: int,
                 vswitch_ids: Sequence[str]):
        """
        :param int active_capacity: Number of active instances in scaling group.
        :param int cooldown_time: Default cooldown time of scaling group.
        :param str creation_time: Creation time of scaling group.
        :param Sequence[str] db_instance_ids: Db instances id which the ECS instance attached to.
        :param str id: ID of the scaling group.
        :param str launch_template_id: Active launch template ID for scaling group.
        :param str launch_template_version: Version of active launch template.
        :param str lifecycle_state: Lifecycle state of scaling group.
        :param Sequence[str] load_balancer_ids: Slb instances id which the ECS instance attached to.
        :param int max_size: The maximum number of ECS instances.
        :param int min_size: The minimum number of ECS instances.
        :param str name: Name of the scaling group.
               * `active_scaling_configuration` -Active scaling configuration for scaling group.
        :param int pending_capacity: Number of pending instances in scaling group.
        :param str region_id: Region ID the scaling group belongs to.
        :param Sequence[str] removal_policies: Removal policy used to select the ECS instance to remove from the scaling group.
        :param int removing_capacity: Number of removing instances in scaling group.
        :param int total_capacity: Number of instances in scaling group.
        :param Sequence[str] vswitch_ids: Vswitches id in which the ECS instance launched.
        """
        pulumi.set(__self__, "active_capacity", active_capacity)
        pulumi.set(__self__, "active_scaling_configuration", active_scaling_configuration)
        pulumi.set(__self__, "cooldown_time", cooldown_time)
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "db_instance_ids", db_instance_ids)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "launch_template_id", launch_template_id)
        pulumi.set(__self__, "launch_template_version", launch_template_version)
        pulumi.set(__self__, "lifecycle_state", lifecycle_state)
        pulumi.set(__self__, "load_balancer_ids", load_balancer_ids)
        pulumi.set(__self__, "max_size", max_size)
        pulumi.set(__self__, "min_size", min_size)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "pending_capacity", pending_capacity)
        pulumi.set(__self__, "region_id", region_id)
        pulumi.set(__self__, "removal_policies", removal_policies)
        pulumi.set(__self__, "removing_capacity", removing_capacity)
        pulumi.set(__self__, "total_capacity", total_capacity)
        pulumi.set(__self__, "vswitch_ids", vswitch_ids)

    @property
    @pulumi.getter(name="activeCapacity")
    def active_capacity(self) -> int:
        """
        Number of active instances in scaling group.
        """
        return pulumi.get(self, "active_capacity")

    @property
    @pulumi.getter(name="activeScalingConfiguration")
    def active_scaling_configuration(self) -> str:
        return pulumi.get(self, "active_scaling_configuration")

    @property
    @pulumi.getter(name="cooldownTime")
    def cooldown_time(self) -> int:
        """
        Default cooldown time of scaling group.
        """
        return pulumi.get(self, "cooldown_time")

    @property
    @pulumi.getter(name="creationTime")
    def creation_time(self) -> str:
        """
        Creation time of scaling group.
        """
        return pulumi.get(self, "creation_time")

    @property
    @pulumi.getter(name="dbInstanceIds")
    def db_instance_ids(self) -> Sequence[str]:
        """
        Db instances id which the ECS instance attached to.
        """
        return pulumi.get(self, "db_instance_ids")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        ID of the scaling group.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="launchTemplateId")
    def launch_template_id(self) -> str:
        """
        Active launch template ID for scaling group.
        """
        return pulumi.get(self, "launch_template_id")

    @property
    @pulumi.getter(name="launchTemplateVersion")
    def launch_template_version(self) -> str:
        """
        Version of active launch template.
        """
        return pulumi.get(self, "launch_template_version")

    @property
    @pulumi.getter(name="lifecycleState")
    def lifecycle_state(self) -> str:
        """
        Lifecycle state of scaling group.
        """
        return pulumi.get(self, "lifecycle_state")

    @property
    @pulumi.getter(name="loadBalancerIds")
    def load_balancer_ids(self) -> Sequence[str]:
        """
        Slb instances id which the ECS instance attached to.
        """
        return pulumi.get(self, "load_balancer_ids")

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> int:
        """
        The maximum number of ECS instances.
        """
        return pulumi.get(self, "max_size")

    @property
    @pulumi.getter(name="minSize")
    def min_size(self) -> int:
        """
        The minimum number of ECS instances.
        """
        return pulumi.get(self, "min_size")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the scaling group.
        * `active_scaling_configuration` -Active scaling configuration for scaling group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="pendingCapacity")
    def pending_capacity(self) -> int:
        """
        Number of pending instances in scaling group.
        """
        return pulumi.get(self, "pending_capacity")

    @property
    @pulumi.getter(name="regionId")
    def region_id(self) -> str:
        """
        Region ID the scaling group belongs to.
        """
        return pulumi.get(self, "region_id")

    @property
    @pulumi.getter(name="removalPolicies")
    def removal_policies(self) -> Sequence[str]:
        """
        Removal policy used to select the ECS instance to remove from the scaling group.
        """
        return pulumi.get(self, "removal_policies")

    @property
    @pulumi.getter(name="removingCapacity")
    def removing_capacity(self) -> int:
        """
        Number of removing instances in scaling group.
        """
        return pulumi.get(self, "removing_capacity")

    @property
    @pulumi.getter(name="totalCapacity")
    def total_capacity(self) -> int:
        """
        Number of instances in scaling group.
        """
        return pulumi.get(self, "total_capacity")

    @property
    @pulumi.getter(name="vswitchIds")
    def vswitch_ids(self) -> Sequence[str]:
        """
        Vswitches id in which the ECS instance launched.
        """
        return pulumi.get(self, "vswitch_ids")


@pulumi.output_type
class GetScalingRulesRuleResult(dict):
    def __init__(__self__, *,
                 adjustment_type: str,
                 adjustment_value: int,
                 cooldown: int,
                 id: str,
                 min_adjustment_magnitude: int,
                 name: str,
                 scaling_group_id: str,
                 scaling_rule_ari: str,
                 type: str):
        """
        :param str adjustment_type: Adjustment type of the scaling rule.
        :param int adjustment_value: Adjustment value of the scaling rule.
        :param int cooldown: Cooldown time of the scaling rule.
        :param str id: ID of the scaling rule.
        :param int min_adjustment_magnitude: Min adjustment magnitude of scaling rule.
        :param str name: Name of the scaling rule.
        :param str scaling_group_id: Scaling group id the scaling rules belong to.
        :param str scaling_rule_ari: Ari of scaling rule.
        :param str type: Type of scaling rule.
        """
        pulumi.set(__self__, "adjustment_type", adjustment_type)
        pulumi.set(__self__, "adjustment_value", adjustment_value)
        pulumi.set(__self__, "cooldown", cooldown)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "min_adjustment_magnitude", min_adjustment_magnitude)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "scaling_group_id", scaling_group_id)
        pulumi.set(__self__, "scaling_rule_ari", scaling_rule_ari)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="adjustmentType")
    def adjustment_type(self) -> str:
        """
        Adjustment type of the scaling rule.
        """
        return pulumi.get(self, "adjustment_type")

    @property
    @pulumi.getter(name="adjustmentValue")
    def adjustment_value(self) -> int:
        """
        Adjustment value of the scaling rule.
        """
        return pulumi.get(self, "adjustment_value")

    @property
    @pulumi.getter
    def cooldown(self) -> int:
        """
        Cooldown time of the scaling rule.
        """
        return pulumi.get(self, "cooldown")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        ID of the scaling rule.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="minAdjustmentMagnitude")
    def min_adjustment_magnitude(self) -> int:
        """
        Min adjustment magnitude of scaling rule.
        """
        return pulumi.get(self, "min_adjustment_magnitude")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the scaling rule.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="scalingGroupId")
    def scaling_group_id(self) -> str:
        """
        Scaling group id the scaling rules belong to.
        """
        return pulumi.get(self, "scaling_group_id")

    @property
    @pulumi.getter(name="scalingRuleAri")
    def scaling_rule_ari(self) -> str:
        """
        Ari of scaling rule.
        """
        return pulumi.get(self, "scaling_rule_ari")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of scaling rule.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetScheduledTasksTaskResult(dict):
    def __init__(__self__, *,
                 description: str,
                 id: str,
                 launch_expiration_time: int,
                 launch_time: str,
                 max_value: int,
                 min_value: int,
                 name: str,
                 recurrence_end_time: str,
                 recurrence_type: str,
                 recurrence_value: str,
                 scheduled_action: str,
                 task_enabled: bool):
        """
        :param str description: Description of the scheduled task.
        :param str id: ID of the scheduled task id.
        :param int launch_expiration_time: The time period during which a failed scheduled task is retried.
        :param str launch_time: The time at which the scheduled task is triggered.
        :param str name: Name of the scheduled task name.
        :param str recurrence_end_time: Specifies the end time after which the scheduled task is no longer repeated.
        :param str recurrence_type: Specifies the recurrence type of the scheduled task.
        :param str recurrence_value: Specifies how often a scheduled task recurs.
        :param str scheduled_action: The operation to be performed when a scheduled task is triggered.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "launch_expiration_time", launch_expiration_time)
        pulumi.set(__self__, "launch_time", launch_time)
        pulumi.set(__self__, "max_value", max_value)
        pulumi.set(__self__, "min_value", min_value)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "recurrence_end_time", recurrence_end_time)
        pulumi.set(__self__, "recurrence_type", recurrence_type)
        pulumi.set(__self__, "recurrence_value", recurrence_value)
        pulumi.set(__self__, "scheduled_action", scheduled_action)
        pulumi.set(__self__, "task_enabled", task_enabled)

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Description of the scheduled task.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        ID of the scheduled task id.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="launchExpirationTime")
    def launch_expiration_time(self) -> int:
        """
        The time period during which a failed scheduled task is retried.
        """
        return pulumi.get(self, "launch_expiration_time")

    @property
    @pulumi.getter(name="launchTime")
    def launch_time(self) -> str:
        """
        The time at which the scheduled task is triggered.
        """
        return pulumi.get(self, "launch_time")

    @property
    @pulumi.getter(name="maxValue")
    def max_value(self) -> int:
        return pulumi.get(self, "max_value")

    @property
    @pulumi.getter(name="minValue")
    def min_value(self) -> int:
        return pulumi.get(self, "min_value")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the scheduled task name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="recurrenceEndTime")
    def recurrence_end_time(self) -> str:
        """
        Specifies the end time after which the scheduled task is no longer repeated.
        """
        return pulumi.get(self, "recurrence_end_time")

    @property
    @pulumi.getter(name="recurrenceType")
    def recurrence_type(self) -> str:
        """
        Specifies the recurrence type of the scheduled task.
        """
        return pulumi.get(self, "recurrence_type")

    @property
    @pulumi.getter(name="recurrenceValue")
    def recurrence_value(self) -> str:
        """
        Specifies how often a scheduled task recurs.
        """
        return pulumi.get(self, "recurrence_value")

    @property
    @pulumi.getter(name="scheduledAction")
    def scheduled_action(self) -> str:
        """
        The operation to be performed when a scheduled task is triggered.
        """
        return pulumi.get(self, "scheduled_action")

    @property
    @pulumi.getter(name="taskEnabled")
    def task_enabled(self) -> bool:
        return pulumi.get(self, "task_enabled")


