# 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, Dict, List, Mapping, Optional, Tuple, Union
from .. import _utilities, _tables
from . import outputs

__all__ = [
    'AutoProvisioningGroupLaunchTemplateConfig',
    'DedicatedHostNetworkAttribute',
    'ImageDiskDeviceMapping',
    'ImageImportDiskDeviceMapping',
    'InstanceDataDisk',
    'LaunchTemplateDataDisk',
    'LaunchTemplateNetworkInterfaces',
    'GetDedicatedHostsHostResult',
    'GetDisksDiskResult',
    'GetEipsEipResult',
    'GetImagesImageResult',
    'GetImagesImageDiskDeviceMappingResult',
    'GetInstanceTypeFamiliesFamilyResult',
    'GetInstanceTypesInstanceTypeResult',
    'GetInstanceTypesInstanceTypeBurstableInstanceResult',
    'GetInstanceTypesInstanceTypeGpuResult',
    'GetInstanceTypesInstanceTypeLocalStorageResult',
    'GetInstancesInstanceResult',
    'GetInstancesInstanceDiskDeviceMappingResult',
    'GetKeyPairsKeyPairResult',
    'GetKeyPairsKeyPairInstanceResult',
    'GetNetworkInterfacesInterfaceResult',
    'GetSecurityGroupRulesRuleResult',
    'GetSecurityGroupsGroupResult',
    'GetSnapshotsSnapshotResult',
]

@pulumi.output_type
class AutoProvisioningGroupLaunchTemplateConfig(dict):
    def __init__(__self__, *,
                 max_price: str,
                 vswitch_id: str,
                 instance_type: Optional[str] = None,
                 priority: Optional[str] = None,
                 weighted_capacity: Optional[str] = None):
        pulumi.set(__self__, "max_price", max_price)
        pulumi.set(__self__, "vswitch_id", vswitch_id)
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if weighted_capacity is not None:
            pulumi.set(__self__, "weighted_capacity", weighted_capacity)

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

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

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

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

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class DedicatedHostNetworkAttribute(dict):
    def __init__(__self__, *,
                 slb_udp_timeout: Optional[float] = None,
                 udp_timeout: Optional[float] = None):
        """
        :param float slb_udp_timeout: The timeout period for a UDP session between Server Load Balancer (SLB) and the dedicated host. Unit: seconds. Valid values: 15 to 310.
        :param float udp_timeout: The timeout period for a UDP session between a user and an Alibaba Cloud service on the dedicated host. Unit: seconds. Valid values: 15 to 310.
        """
        if slb_udp_timeout is not None:
            pulumi.set(__self__, "slb_udp_timeout", slb_udp_timeout)
        if udp_timeout is not None:
            pulumi.set(__self__, "udp_timeout", udp_timeout)

    @property
    @pulumi.getter(name="slbUdpTimeout")
    def slb_udp_timeout(self) -> Optional[float]:
        """
        The timeout period for a UDP session between Server Load Balancer (SLB) and the dedicated host. Unit: seconds. Valid values: 15 to 310.
        """
        return pulumi.get(self, "slb_udp_timeout")

    @property
    @pulumi.getter(name="udpTimeout")
    def udp_timeout(self) -> Optional[float]:
        """
        The timeout period for a UDP session between a user and an Alibaba Cloud service on the dedicated host. Unit: seconds. Valid values: 15 to 310.
        """
        return pulumi.get(self, "udp_timeout")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ImageDiskDeviceMapping(dict):
    def __init__(__self__, *,
                 device: Optional[str] = None,
                 disk_type: Optional[str] = None,
                 size: Optional[float] = None,
                 snapshot_id: Optional[str] = None):
        """
        :param str device: Specifies the name of a disk in the combined custom image. Value range: /dev/xvda to /dev/xvdz.
        :param str disk_type: Specifies the type of a disk in the combined custom image. If you specify this parameter, you can use a data disk snapshot as the data source of a system disk for creating an image. If it is not specified, the disk type is determined by the corresponding snapshot. Valid values: `system`, `data`,
        :param float size: Specifies the size of a disk in the combined custom image, in GiB. Value range: 5 to 2000.
        :param str snapshot_id: Specifies a snapshot that is used to create a combined custom image.
        """
        if device is not None:
            pulumi.set(__self__, "device", device)
        if disk_type is not None:
            pulumi.set(__self__, "disk_type", disk_type)
        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 device(self) -> Optional[str]:
        """
        Specifies the name of a disk in the combined custom image. Value range: /dev/xvda to /dev/xvdz.
        """
        return pulumi.get(self, "device")

    @property
    @pulumi.getter(name="diskType")
    def disk_type(self) -> Optional[str]:
        """
        Specifies the type of a disk in the combined custom image. If you specify this parameter, you can use a data disk snapshot as the data source of a system disk for creating an image. If it is not specified, the disk type is determined by the corresponding snapshot. Valid values: `system`, `data`,
        """
        return pulumi.get(self, "disk_type")

    @property
    @pulumi.getter
    def size(self) -> Optional[float]:
        """
        Specifies the size of a disk in the combined custom image, in GiB. Value range: 5 to 2000.
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="snapshotId")
    def snapshot_id(self) -> Optional[str]:
        """
        Specifies a snapshot that is used to create a combined custom image.
        """
        return pulumi.get(self, "snapshot_id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class ImageImportDiskDeviceMapping(dict):
    def __init__(__self__, *,
                 device: Optional[str] = None,
                 disk_image_size: Optional[float] = None,
                 format: Optional[str] = None,
                 oss_bucket: Optional[str] = None,
                 oss_object: Optional[str] = None):
        """
        :param str device: The name of disk N in the custom image.
        :param float disk_image_size: Resolution size. You must ensure that the system disk space ≥ file system space. Ranges: When n = 1, the system disk: 5 ~ 500GiB, When n = 2 ~ 17, that is, data disk: 5 ~ 1000GiB, When temporary is introduced, the system automatically detects the size, which is subject to the detection result.
        :param str format: Image format. Value range: When the `RAW`, `VHD`, `qcow2` is imported into the image, the system automatically detects the image format, whichever comes first.
        :param str oss_bucket: Save the exported OSS bucket.
        :param str oss_object: The file name of your OSS Object.
        """
        if device is not None:
            pulumi.set(__self__, "device", device)
        if disk_image_size is not None:
            pulumi.set(__self__, "disk_image_size", disk_image_size)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if oss_bucket is not None:
            pulumi.set(__self__, "oss_bucket", oss_bucket)
        if oss_object is not None:
            pulumi.set(__self__, "oss_object", oss_object)

    @property
    @pulumi.getter
    def device(self) -> Optional[str]:
        """
        The name of disk N in the custom image.
        """
        return pulumi.get(self, "device")

    @property
    @pulumi.getter(name="diskImageSize")
    def disk_image_size(self) -> Optional[float]:
        """
        Resolution size. You must ensure that the system disk space ≥ file system space. Ranges: When n = 1, the system disk: 5 ~ 500GiB, When n = 2 ~ 17, that is, data disk: 5 ~ 1000GiB, When temporary is introduced, the system automatically detects the size, which is subject to the detection result.
        """
        return pulumi.get(self, "disk_image_size")

    @property
    @pulumi.getter
    def format(self) -> Optional[str]:
        """
        Image format. Value range: When the `RAW`, `VHD`, `qcow2` is imported into the image, the system automatically detects the image format, whichever comes first.
        """
        return pulumi.get(self, "format")

    @property
    @pulumi.getter(name="ossBucket")
    def oss_bucket(self) -> Optional[str]:
        """
        Save the exported OSS bucket.
        """
        return pulumi.get(self, "oss_bucket")

    @property
    @pulumi.getter(name="ossObject")
    def oss_object(self) -> Optional[str]:
        """
        The file name of your OSS Object.
        """
        return pulumi.get(self, "oss_object")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class InstanceDataDisk(dict):
    def __init__(__self__, *,
                 size: float,
                 auto_snapshot_policy_id: Optional[str] = None,
                 category: Optional[str] = None,
                 delete_with_instance: Optional[bool] = None,
                 description: Optional[str] = None,
                 encrypted: Optional[bool] = None,
                 kms_key_id: Optional[str] = None,
                 name: Optional[str] = None,
                 snapshot_id: Optional[str] = None):
        """
        :param float size: The size of the data disk.
               - cloud：[5, 2000]
               - cloud_efficiency：[20, 32768]
               - cloud_ssd：[20, 32768]
               - cloud_essd：[20, 32768]
               - ephemeral_ssd: [5, 800]
        :param str auto_snapshot_policy_id: The ID of the automatic snapshot policy applied to the system disk.
        :param str category: The category of the disk:
               - `cloud`: The general cloud disk.
               - `cloud_efficiency`: The efficiency cloud disk.
               - `cloud_ssd`: The SSD cloud disk.
               - `cloud_essd`: The ESSD cloud disk.
               - `ephemeral_ssd`: The local SSD disk.
               Default to `cloud_efficiency`.
        :param bool delete_with_instance: Delete this data disk when the instance is destroyed. It only works on cloud, cloud_efficiency, cloud_essd, cloud_ssd disk. If the category of this data disk was ephemeral_ssd, please don't set this param. Default value: `true`.
        :param str description: The description of the data disk.
        :param bool encrypted: -(Optional, Bool, ForceNew) Encrypted the data in this disk. Default value: `false`.
        :param str kms_key_id: The KMS key ID corresponding to the Nth data disk.
        :param str name: The name of the data disk.
        :param str snapshot_id: The snapshot ID used to initialize the data disk. If the size specified by snapshot is greater that the size of the disk, use the size specified by snapshot as the size of the data disk.
        """
        pulumi.set(__self__, "size", size)
        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 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 snapshot_id is not None:
            pulumi.set(__self__, "snapshot_id", snapshot_id)

    @property
    @pulumi.getter
    def size(self) -> float:
        """
        The size of the data disk.
        - cloud：[5, 2000]
        - cloud_efficiency：[20, 32768]
        - cloud_ssd：[20, 32768]
        - cloud_essd：[20, 32768]
        - ephemeral_ssd: [5, 800]
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="autoSnapshotPolicyId")
    def auto_snapshot_policy_id(self) -> Optional[str]:
        """
        The ID of the automatic snapshot policy applied to the system disk.
        """
        return pulumi.get(self, "auto_snapshot_policy_id")

    @property
    @pulumi.getter
    def category(self) -> Optional[str]:
        """
        The category of the disk:
        - `cloud`: The general cloud disk.
        - `cloud_efficiency`: The efficiency cloud disk.
        - `cloud_ssd`: The SSD cloud disk.
        - `cloud_essd`: The ESSD cloud disk.
        - `ephemeral_ssd`: The local SSD disk.
        Default to `cloud_efficiency`.
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter(name="deleteWithInstance")
    def delete_with_instance(self) -> Optional[bool]:
        """
        Delete this data disk when the instance is destroyed. It only works on cloud, cloud_efficiency, cloud_essd, cloud_ssd disk. If the category of this data disk was ephemeral_ssd, please don't set this param. Default value: `true`.
        """
        return pulumi.get(self, "delete_with_instance")

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

    @property
    @pulumi.getter
    def encrypted(self) -> Optional[bool]:
        """
        -(Optional, Bool, ForceNew) Encrypted the data in this disk. Default value: `false`.
        """
        return pulumi.get(self, "encrypted")

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[str]:
        """
        The KMS key ID corresponding to the Nth data disk.
        """
        return pulumi.get(self, "kms_key_id")

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

    @property
    @pulumi.getter(name="snapshotId")
    def snapshot_id(self) -> Optional[str]:
        """
        The snapshot ID used to initialize the data disk. If the size specified by snapshot is greater that the size of the disk, use the size specified by snapshot as the size of the data disk.
        """
        return pulumi.get(self, "snapshot_id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class LaunchTemplateDataDisk(dict):
    def __init__(__self__, *,
                 category: Optional[str] = None,
                 delete_with_instance: Optional[bool] = None,
                 description: Optional[str] = None,
                 encrypted: Optional[bool] = None,
                 name: Optional[str] = None,
                 size: Optional[float] = None,
                 snapshot_id: Optional[str] = None):
        """
        :param str category: The category of the disk:
               - cloud: Basic cloud disk.
               - cloud_efficiency: Ultra cloud disk.
               - cloud_ssd: SSD cloud Disks.
               - ephemeral_ssd: local SSD Disks
               - cloud_essd: ESSD cloud Disks.
        :param bool delete_with_instance: Delete this data disk when the instance is destroyed. It only works on cloud, cloud_efficiency, cloud_ssd and cloud_essd disk. If the category of this data disk was ephemeral_ssd, please don't set this param.
        :param str description: The description of the data disk.
        :param bool encrypted: -(Optional, Bool) Encrypted the data in this disk.
        :param str name: The name of the data disk.
        :param float size: The size of the data disk.
               - cloud：[5, 2000]
               - cloud_efficiency：[20, 32768]
               - cloud_ssd：[20, 32768]
               - cloud_essd：[20, 32768]
               - ephemeral_ssd: [5, 800]
        :param str snapshot_id: The snapshot ID used to initialize the data disk. If the size specified by snapshot is greater that the size of the disk, use the size specified by snapshot as the size of the 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 description is not None:
            pulumi.set(__self__, "description", description)
        if encrypted is not None:
            pulumi.set(__self__, "encrypted", encrypted)
        if name is not None:
            pulumi.set(__self__, "name", name)
        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]:
        """
        The category of the disk:
        - cloud: Basic cloud disk.
        - cloud_efficiency: Ultra cloud disk.
        - cloud_ssd: SSD cloud Disks.
        - ephemeral_ssd: local SSD Disks
        - cloud_essd: ESSD cloud Disks.
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter(name="deleteWithInstance")
    def delete_with_instance(self) -> Optional[bool]:
        """
        Delete this data disk when the instance is destroyed. It only works on cloud, cloud_efficiency, cloud_ssd and cloud_essd disk. If the category of this data disk was ephemeral_ssd, please don't set this param.
        """
        return pulumi.get(self, "delete_with_instance")

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

    @property
    @pulumi.getter
    def encrypted(self) -> Optional[bool]:
        """
        -(Optional, Bool) Encrypted the data in this disk.
        """
        return pulumi.get(self, "encrypted")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[float]:
        """
        The size of the data disk.
        - cloud：[5, 2000]
        - cloud_efficiency：[20, 32768]
        - cloud_ssd：[20, 32768]
        - cloud_essd：[20, 32768]
        - ephemeral_ssd: [5, 800]
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="snapshotId")
    def snapshot_id(self) -> Optional[str]:
        """
        The snapshot ID used to initialize the data disk. If the size specified by snapshot is greater that the size of the disk, use the size specified by snapshot as the size of the data disk.
        """
        return pulumi.get(self, "snapshot_id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class LaunchTemplateNetworkInterfaces(dict):
    def __init__(__self__, *,
                 description: Optional[str] = None,
                 name: Optional[str] = None,
                 primary_ip: Optional[str] = None,
                 security_group_id: Optional[str] = None,
                 vswitch_id: Optional[str] = None):
        """
        :param str description: The description of the data disk.
        :param str name: The name of the data disk.
        :param str primary_ip: The primary private IP address of the ENI.
        :param str security_group_id: The security group ID must be one in the same VPC.
        :param str vswitch_id: The VSwitch ID for ENI. The instance must be in the same zone of the same VPC network as the ENI, but they may belong to different VSwitches.
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if primary_ip is not None:
            pulumi.set(__self__, "primary_ip", primary_ip)
        if security_group_id is not None:
            pulumi.set(__self__, "security_group_id", security_group_id)
        if vswitch_id is not None:
            pulumi.set(__self__, "vswitch_id", vswitch_id)

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

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

    @property
    @pulumi.getter(name="primaryIp")
    def primary_ip(self) -> Optional[str]:
        """
        The primary private IP address of the ENI.
        """
        return pulumi.get(self, "primary_ip")

    @property
    @pulumi.getter(name="securityGroupId")
    def security_group_id(self) -> Optional[str]:
        """
        The security group ID must be one in the same VPC.
        """
        return pulumi.get(self, "security_group_id")

    @property
    @pulumi.getter(name="vswitchId")
    def vswitch_id(self) -> Optional[str]:
        """
        The VSwitch ID for ENI. The instance must be in the same zone of the same VPC network as the ENI, but they may belong to different VSwitches.
        """
        return pulumi.get(self, "vswitch_id")

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class GetDedicatedHostsHostResult(dict):
    def __init__(__self__, *,
                 action_on_maintenance: str,
                 auto_placement: str,
                 auto_release_time: str,
                 cores: float,
                 dedicated_host_id: str,
                 dedicated_host_name: str,
                 dedicated_host_type: str,
                 description: str,
                 expired_time: str,
                 gpu_spec: str,
                 id: str,
                 machine_id: str,
                 payment_type: str,
                 physical_gpus: float,
                 resource_group_id: str,
                 sale_cycle: str,
                 sockets: float,
                 status: str,
                 supported_instance_types_lists: List[str],
                 tags: Mapping[str, Any],
                 zone_id: str):
        """
        :param str action_on_maintenance: The policy used to migrate the instances from the dedicated host when the dedicated host fails or needs to be repaired online.
        :param str auto_placement: Specifies whether to add the dedicated host to the resource pool for automatic deployment.
        :param str auto_release_time: The automatic release time of the dedicated host.
        :param float cores: A mapping of tags to assign to the resource.
        :param str dedicated_host_id: The ID of ECS Dedicated Host.
        :param str dedicated_host_name: The name of ECS Dedicated Host.
        :param str dedicated_host_type: The type of the dedicated host.
        :param str description: The description of the dedicated host.
        :param str expired_time: The expiration time of the subscription dedicated host.
        :param str gpu_spec: The GPU model.
        :param str id: ID of the ECS Dedicated Host.
        :param str machine_id: The machine code of the dedicated host.
        :param str payment_type: The billing method of the dedicated host.
        :param float physical_gpus: The number of physical GPUs.
        :param str resource_group_id: The ID of the resource group to which the ECS Dedicated Host belongs.
        :param str sale_cycle: The unit of the subscription billing method.
        :param float sockets: The number of physical CPUs.
        :param str status: The status of the ECS Dedicated Host. validate value: `Available`, `Creating`, `PermanentFailure`, `Released`, `UnderAssessment`.
        :param List[str] supported_instance_types_lists: The list of ECS instanc
        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
        :param str zone_id: The zone ID of the ECS Dedicated Host.
        """
        pulumi.set(__self__, "action_on_maintenance", action_on_maintenance)
        pulumi.set(__self__, "auto_placement", auto_placement)
        pulumi.set(__self__, "auto_release_time", auto_release_time)
        pulumi.set(__self__, "cores", cores)
        pulumi.set(__self__, "dedicated_host_id", dedicated_host_id)
        pulumi.set(__self__, "dedicated_host_name", dedicated_host_name)
        pulumi.set(__self__, "dedicated_host_type", dedicated_host_type)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "expired_time", expired_time)
        pulumi.set(__self__, "gpu_spec", gpu_spec)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "machine_id", machine_id)
        pulumi.set(__self__, "payment_type", payment_type)
        pulumi.set(__self__, "physical_gpus", physical_gpus)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        pulumi.set(__self__, "sale_cycle", sale_cycle)
        pulumi.set(__self__, "sockets", sockets)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "supported_instance_types_lists", supported_instance_types_lists)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter(name="actionOnMaintenance")
    def action_on_maintenance(self) -> str:
        """
        The policy used to migrate the instances from the dedicated host when the dedicated host fails or needs to be repaired online.
        """
        return pulumi.get(self, "action_on_maintenance")

    @property
    @pulumi.getter(name="autoPlacement")
    def auto_placement(self) -> str:
        """
        Specifies whether to add the dedicated host to the resource pool for automatic deployment.
        """
        return pulumi.get(self, "auto_placement")

    @property
    @pulumi.getter(name="autoReleaseTime")
    def auto_release_time(self) -> str:
        """
        The automatic release time of the dedicated host.
        """
        return pulumi.get(self, "auto_release_time")

    @property
    @pulumi.getter
    def cores(self) -> float:
        """
        A mapping of tags to assign to the resource.
        """
        return pulumi.get(self, "cores")

    @property
    @pulumi.getter(name="dedicatedHostId")
    def dedicated_host_id(self) -> str:
        """
        The ID of ECS Dedicated Host.
        """
        return pulumi.get(self, "dedicated_host_id")

    @property
    @pulumi.getter(name="dedicatedHostName")
    def dedicated_host_name(self) -> str:
        """
        The name of ECS Dedicated Host.
        """
        return pulumi.get(self, "dedicated_host_name")

    @property
    @pulumi.getter(name="dedicatedHostType")
    def dedicated_host_type(self) -> str:
        """
        The type of the dedicated host.
        """
        return pulumi.get(self, "dedicated_host_type")

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

    @property
    @pulumi.getter(name="expiredTime")
    def expired_time(self) -> str:
        """
        The expiration time of the subscription dedicated host.
        """
        return pulumi.get(self, "expired_time")

    @property
    @pulumi.getter(name="gpuSpec")
    def gpu_spec(self) -> str:
        """
        The GPU model.
        """
        return pulumi.get(self, "gpu_spec")

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

    @property
    @pulumi.getter(name="machineId")
    def machine_id(self) -> str:
        """
        The machine code of the dedicated host.
        """
        return pulumi.get(self, "machine_id")

    @property
    @pulumi.getter(name="paymentType")
    def payment_type(self) -> str:
        """
        The billing method of the dedicated host.
        """
        return pulumi.get(self, "payment_type")

    @property
    @pulumi.getter(name="physicalGpus")
    def physical_gpus(self) -> float:
        """
        The number of physical GPUs.
        """
        return pulumi.get(self, "physical_gpus")

    @property
    @pulumi.getter(name="resourceGroupId")
    def resource_group_id(self) -> str:
        """
        The ID of the resource group to which the ECS Dedicated Host belongs.
        """
        return pulumi.get(self, "resource_group_id")

    @property
    @pulumi.getter(name="saleCycle")
    def sale_cycle(self) -> str:
        """
        The unit of the subscription billing method.
        """
        return pulumi.get(self, "sale_cycle")

    @property
    @pulumi.getter
    def sockets(self) -> float:
        """
        The number of physical CPUs.
        """
        return pulumi.get(self, "sockets")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the ECS Dedicated Host. validate value: `Available`, `Creating`, `PermanentFailure`, `Released`, `UnderAssessment`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="supportedInstanceTypesLists")
    def supported_instance_types_lists(self) -> List[str]:
        """
        The list of ECS instanc
        """
        return pulumi.get(self, "supported_instance_types_lists")

    @property
    @pulumi.getter
    def tags(self) -> Mapping[str, Any]:
        """
        A mapping of tags to assign to the resource.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> str:
        """
        The zone ID of the ECS Dedicated Host.
        """
        return pulumi.get(self, "zone_id")


@pulumi.output_type
class GetDisksDiskResult(dict):
    def __init__(__self__, *,
                 attached_time: str,
                 availability_zone: str,
                 category: str,
                 creation_time: str,
                 description: str,
                 detached_time: str,
                 encrypted: str,
                 expiration_time: str,
                 id: str,
                 image_id: str,
                 instance_id: str,
                 name: str,
                 region_id: str,
                 resource_group_id: str,
                 size: float,
                 snapshot_id: str,
                 status: str,
                 type: str,
                 tags: Optional[Mapping[str, Any]] = None):
        """
        :param str attached_time: Disk attachment time.
        :param str availability_zone: Availability zone of the disk.
        :param str category: Disk category. Possible values: `cloud` (basic cloud disk), `cloud_efficiency` (ultra cloud disk), `ephemeral_ssd` (local SSD cloud disk), `cloud_ssd` (SSD cloud disk), and `cloud_essd` (ESSD cloud disk).
        :param str creation_time: Disk creation time.
        :param str description: Disk description.
        :param str detached_time: Disk detachment time.
        :param str encrypted: Indicate whether the disk is encrypted or not. Possible values: `on` and `off`.
        :param str expiration_time: Disk expiration time.
        :param str id: ID of the disk.
        :param str image_id: ID of the image from which the disk is created. It is null unless the disk is created using an image.
        :param str instance_id: Filter the results by the specified ECS instance ID.
        :param str name: Disk name.
        :param str region_id: Region ID the disk belongs to.
        :param str resource_group_id: The Id of resource group which the disk belongs.
        :param float size: Disk size in GiB.
        :param str snapshot_id: Snapshot used to create the disk. It is null if no snapshot is used to create the disk.
        :param str status: Current status. Possible values: `In_use`, `Available`, `Attaching`, `Detaching`, `Creating` and `ReIniting`.
        :param str type: Disk type. Possible values: `system` and `data`.
        :param Mapping[str, Any] tags: A map of tags assigned to the disks. It must be in the format:
               ```python
               import pulumi
               import pulumi_alicloud as alicloud
               
               disks_ds = alicloud.ecs.get_disks(tags={
                   "tagKey1": "tagValue1",
                   "tagKey2": "tagValue2",
               })
               ```
        """
        pulumi.set(__self__, "attached_time", attached_time)
        pulumi.set(__self__, "availability_zone", availability_zone)
        pulumi.set(__self__, "category", category)
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "detached_time", detached_time)
        pulumi.set(__self__, "encrypted", encrypted)
        pulumi.set(__self__, "expiration_time", expiration_time)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "image_id", image_id)
        pulumi.set(__self__, "instance_id", instance_id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "region_id", region_id)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "snapshot_id", snapshot_id)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "type", type)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter(name="attachedTime")
    def attached_time(self) -> str:
        """
        Disk attachment time.
        """
        return pulumi.get(self, "attached_time")

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> str:
        """
        Availability zone of the disk.
        """
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter
    def category(self) -> str:
        """
        Disk category. Possible values: `cloud` (basic cloud disk), `cloud_efficiency` (ultra cloud disk), `ephemeral_ssd` (local SSD cloud disk), `cloud_ssd` (SSD cloud disk), and `cloud_essd` (ESSD cloud disk).
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter(name="creationTime")
    def creation_time(self) -> str:
        """
        Disk creation time.
        """
        return pulumi.get(self, "creation_time")

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

    @property
    @pulumi.getter(name="detachedTime")
    def detached_time(self) -> str:
        """
        Disk detachment time.
        """
        return pulumi.get(self, "detached_time")

    @property
    @pulumi.getter
    def encrypted(self) -> str:
        """
        Indicate whether the disk is encrypted or not. Possible values: `on` and `off`.
        """
        return pulumi.get(self, "encrypted")

    @property
    @pulumi.getter(name="expirationTime")
    def expiration_time(self) -> str:
        """
        Disk expiration time.
        """
        return pulumi.get(self, "expiration_time")

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

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> str:
        """
        ID of the image from which the disk is created. It is null unless the disk is created using an image.
        """
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> str:
        """
        Filter the results by the specified ECS instance ID.
        """
        return pulumi.get(self, "instance_id")

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

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

    @property
    @pulumi.getter(name="resourceGroupId")
    def resource_group_id(self) -> str:
        """
        The Id of resource group which the disk belongs.
        """
        return pulumi.get(self, "resource_group_id")

    @property
    @pulumi.getter
    def size(self) -> float:
        """
        Disk size in GiB.
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="snapshotId")
    def snapshot_id(self) -> str:
        """
        Snapshot used to create the disk. It is null if no snapshot is used to create the disk.
        """
        return pulumi.get(self, "snapshot_id")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        Current status. Possible values: `In_use`, `Available`, `Attaching`, `Detaching`, `Creating` and `ReIniting`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Disk type. Possible values: `system` and `data`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Mapping[str, Any]]:
        """
        A map of tags assigned to the disks. It must be in the format:
        ```python
        import pulumi
        import pulumi_alicloud as alicloud

        disks_ds = alicloud.ecs.get_disks(tags={
            "tagKey1": "tagValue1",
            "tagKey2": "tagValue2",
        })
        ```
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetEipsEipResult(dict):
    def __init__(__self__, *,
                 bandwidth: str,
                 creation_time: str,
                 id: str,
                 instance_id: str,
                 instance_type: str,
                 internet_charge_type: str,
                 ip_address: str,
                 status: str):
        """
        :param str bandwidth: EIP internet max bandwidth in Mbps.
        :param str creation_time: Time of creation.
        :param str id: ID of the EIP.
        :param str instance_id: The ID of the instance that is being bound.
        :param str instance_type: The instance type of that the EIP is bound.
        :param str internet_charge_type: EIP internet charge type.
        :param str ip_address: Public IP Address of the the EIP.
        :param str status: EIP status. Possible values are: `Associating`, `Unassociating`, `InUse` and `Available`.
        """
        pulumi.set(__self__, "bandwidth", bandwidth)
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "instance_id", instance_id)
        pulumi.set(__self__, "instance_type", instance_type)
        pulumi.set(__self__, "internet_charge_type", internet_charge_type)
        pulumi.set(__self__, "ip_address", ip_address)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter
    def bandwidth(self) -> str:
        """
        EIP internet max bandwidth in Mbps.
        """
        return pulumi.get(self, "bandwidth")

    @property
    @pulumi.getter(name="creationTime")
    def creation_time(self) -> str:
        """
        Time of creation.
        """
        return pulumi.get(self, "creation_time")

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

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> str:
        """
        The ID of the instance that is being bound.
        """
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> str:
        """
        The instance type of that the EIP is bound.
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="internetChargeType")
    def internet_charge_type(self) -> str:
        """
        EIP internet charge type.
        """
        return pulumi.get(self, "internet_charge_type")

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> str:
        """
        Public IP Address of the the EIP.
        """
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        EIP status. Possible values are: `Associating`, `Unassociating`, `InUse` and `Available`.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetImagesImageResult(dict):
    def __init__(__self__, *,
                 architecture: str,
                 creation_time: str,
                 description: str,
                 disk_device_mappings: List['outputs.GetImagesImageDiskDeviceMappingResult'],
                 id: str,
                 image_id: str,
                 image_owner_alias: str,
                 image_version: str,
                 is_copied: bool,
                 is_self_shared: str,
                 is_subscribed: bool,
                 is_support_io_optimized: bool,
                 name: str,
                 os_name: str,
                 os_name_en: str,
                 os_type: str,
                 platform: str,
                 product_code: str,
                 progress: str,
                 size: float,
                 state: str,
                 status: str,
                 usage: str,
                 tags: Optional[Mapping[str, Any]] = None):
        """
        :param str architecture: The image architecture. Valid values: `i386` and `x86_64`.
        :param str creation_time: Time of creation.
        :param str description: Description of the image.
        :param List['GetImagesImageDiskDeviceMappingArgs'] disk_device_mappings: Description of the system with disks and snapshots under the image.
        :param str id: ID of the image.
        :param str image_owner_alias: Alias of the image owner.
        :param str image_version: Version of the image.
        :param bool is_subscribed: Whether the user has subscribed to the terms of service for the image product corresponding to the ProductCode.
        :param bool is_support_io_optimized: Specifies whether the image can be used on I/O optimized instances.
        :param str os_name: Display Chinese name of the OS.
        :param str os_name_en: Display English name of the OS.
        :param str os_type: The operating system type of the image. Valid values: `windows` and `linux`.
        :param str product_code: Product code of the image on the image market.
        :param str progress: Progress of image creation, presented in percentages.
        :param float size: Size of the created disk.
        :param str status: The status of the image. The following values are available, Separate multiple parameter values by using commas (,). Default value: `Available`. Valid values: 
               * `Creating`: The image is being created.
               * `Waiting`: The image is waiting to be processed.
               * `Available`: The image is available.
               * `UnAvailable`: The image is unavailable.
               * `CreateFailed`: The image failed to be created.
               * `Deprecated`: The image is discontinued.
        :param str usage: Specifies whether to check the validity of the request without actually making the request. Valid values:                                           
               * `instance`: The image is already in use and running on an ECS instance.
               * `none`: The image is not in use.
        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
        """
        pulumi.set(__self__, "architecture", architecture)
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "disk_device_mappings", disk_device_mappings)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "image_id", image_id)
        pulumi.set(__self__, "image_owner_alias", image_owner_alias)
        pulumi.set(__self__, "image_version", image_version)
        pulumi.set(__self__, "is_copied", is_copied)
        pulumi.set(__self__, "is_self_shared", is_self_shared)
        pulumi.set(__self__, "is_subscribed", is_subscribed)
        pulumi.set(__self__, "is_support_io_optimized", is_support_io_optimized)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "os_name", os_name)
        pulumi.set(__self__, "os_name_en", os_name_en)
        pulumi.set(__self__, "os_type", os_type)
        pulumi.set(__self__, "platform", platform)
        pulumi.set(__self__, "product_code", product_code)
        pulumi.set(__self__, "progress", progress)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "usage", usage)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter
    def architecture(self) -> str:
        """
        The image architecture. Valid values: `i386` and `x86_64`.
        """
        return pulumi.get(self, "architecture")

    @property
    @pulumi.getter(name="creationTime")
    def creation_time(self) -> str:
        """
        Time of creation.
        """
        return pulumi.get(self, "creation_time")

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

    @property
    @pulumi.getter(name="diskDeviceMappings")
    def disk_device_mappings(self) -> List['outputs.GetImagesImageDiskDeviceMappingResult']:
        """
        Description of the system with disks and snapshots under the image.
        """
        return pulumi.get(self, "disk_device_mappings")

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

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

    @property
    @pulumi.getter(name="imageOwnerAlias")
    def image_owner_alias(self) -> str:
        """
        Alias of the image owner.
        """
        return pulumi.get(self, "image_owner_alias")

    @property
    @pulumi.getter(name="imageVersion")
    def image_version(self) -> str:
        """
        Version of the image.
        """
        return pulumi.get(self, "image_version")

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

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

    @property
    @pulumi.getter(name="isSubscribed")
    def is_subscribed(self) -> bool:
        """
        Whether the user has subscribed to the terms of service for the image product corresponding to the ProductCode.
        """
        return pulumi.get(self, "is_subscribed")

    @property
    @pulumi.getter(name="isSupportIoOptimized")
    def is_support_io_optimized(self) -> bool:
        """
        Specifies whether the image can be used on I/O optimized instances.
        """
        return pulumi.get(self, "is_support_io_optimized")

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

    @property
    @pulumi.getter(name="osName")
    def os_name(self) -> str:
        """
        Display Chinese name of the OS.
        """
        return pulumi.get(self, "os_name")

    @property
    @pulumi.getter(name="osNameEn")
    def os_name_en(self) -> str:
        """
        Display English name of the OS.
        """
        return pulumi.get(self, "os_name_en")

    @property
    @pulumi.getter(name="osType")
    def os_type(self) -> str:
        """
        The operating system type of the image. Valid values: `windows` and `linux`.
        """
        return pulumi.get(self, "os_type")

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

    @property
    @pulumi.getter(name="productCode")
    def product_code(self) -> str:
        """
        Product code of the image on the image market.
        """
        return pulumi.get(self, "product_code")

    @property
    @pulumi.getter
    def progress(self) -> str:
        """
        Progress of image creation, presented in percentages.
        """
        return pulumi.get(self, "progress")

    @property
    @pulumi.getter
    def size(self) -> float:
        """
        Size of the created disk.
        """
        return pulumi.get(self, "size")

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

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the image. The following values are available, Separate multiple parameter values by using commas (,). Default value: `Available`. Valid values: 
        * `Creating`: The image is being created.
        * `Waiting`: The image is waiting to be processed.
        * `Available`: The image is available.
        * `UnAvailable`: The image is unavailable.
        * `CreateFailed`: The image failed to be created.
        * `Deprecated`: The image is discontinued.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter
    def usage(self) -> str:
        """
        Specifies whether to check the validity of the request without actually making the request. Valid values:                                           
        * `instance`: The image is already in use and running on an ECS instance.
        * `none`: The image is not in use.
        """
        return pulumi.get(self, "usage")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Mapping[str, Any]]:
        """
        A mapping of tags to assign to the resource.
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetImagesImageDiskDeviceMappingResult(dict):
    def __init__(__self__, *,
                 device: str,
                 size: str,
                 snapshot_id: str):
        """
        :param str device: Device information of the created disk: such as /dev/xvdb.
        :param str size: Size of the created disk.
        :param str snapshot_id: The ID of the snapshot used to create the custom image.
        """
        pulumi.set(__self__, "device", device)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "snapshot_id", snapshot_id)

    @property
    @pulumi.getter
    def device(self) -> str:
        """
        Device information of the created disk: such as /dev/xvdb.
        """
        return pulumi.get(self, "device")

    @property
    @pulumi.getter
    def size(self) -> str:
        """
        Size of the created disk.
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="snapshotId")
    def snapshot_id(self) -> str:
        """
        The ID of the snapshot used to create the custom image.
        """
        return pulumi.get(self, "snapshot_id")


@pulumi.output_type
class GetInstanceTypeFamiliesFamilyResult(dict):
    def __init__(__self__, *,
                 generation: str,
                 id: str,
                 zone_ids: List[str]):
        """
        :param str generation: The generation of the instance type family, Valid values: `ecs-1`, `ecs-2`, `ecs-3` and `ecs-4`. For more information, see [Instance type families](https://www.alibabacloud.com/help/doc-detail/25378.htm).
        :param str id: ID of the instance type family.
        :param List[str] zone_ids: A list of Zone to launch the instance.
        """
        pulumi.set(__self__, "generation", generation)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "zone_ids", zone_ids)

    @property
    @pulumi.getter
    def generation(self) -> str:
        """
        The generation of the instance type family, Valid values: `ecs-1`, `ecs-2`, `ecs-3` and `ecs-4`. For more information, see [Instance type families](https://www.alibabacloud.com/help/doc-detail/25378.htm).
        """
        return pulumi.get(self, "generation")

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

    @property
    @pulumi.getter(name="zoneIds")
    def zone_ids(self) -> List[str]:
        """
        A list of Zone to launch the instance.
        """
        return pulumi.get(self, "zone_ids")


@pulumi.output_type
class GetInstanceTypesInstanceTypeResult(dict):
    def __init__(__self__, *,
                 availability_zones: List[str],
                 burstable_instance: 'outputs.GetInstanceTypesInstanceTypeBurstableInstanceResult',
                 cpu_core_count: float,
                 eni_amount: float,
                 family: str,
                 gpu: 'outputs.GetInstanceTypesInstanceTypeGpuResult',
                 id: str,
                 local_storage: 'outputs.GetInstanceTypesInstanceTypeLocalStorageResult',
                 memory_size: float,
                 price: str):
        """
        :param List[str] availability_zones: List of availability zones that support the instance type.
        :param 'GetInstanceTypesInstanceTypeBurstableInstanceArgs' burstable_instance: The burstable instance attribution:
        :param float cpu_core_count: Filter the results to a specific number of cpu cores.
        :param float eni_amount: Filter the result whose network interface number is no more than `eni_amount`.
        :param str family: The instance type family.
        :param 'GetInstanceTypesInstanceTypeGpuArgs' gpu: The GPU attribution of an instance type:
        :param str id: ID of the instance type.
        :param 'GetInstanceTypesInstanceTypeLocalStorageArgs' local_storage: Local storage of an instance type:
        :param float memory_size: Filter the results to a specific memory size in GB.
        """
        pulumi.set(__self__, "availability_zones", availability_zones)
        pulumi.set(__self__, "burstable_instance", burstable_instance)
        pulumi.set(__self__, "cpu_core_count", cpu_core_count)
        pulumi.set(__self__, "eni_amount", eni_amount)
        pulumi.set(__self__, "family", family)
        pulumi.set(__self__, "gpu", gpu)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "local_storage", local_storage)
        pulumi.set(__self__, "memory_size", memory_size)
        pulumi.set(__self__, "price", price)

    @property
    @pulumi.getter(name="availabilityZones")
    def availability_zones(self) -> List[str]:
        """
        List of availability zones that support the instance type.
        """
        return pulumi.get(self, "availability_zones")

    @property
    @pulumi.getter(name="burstableInstance")
    def burstable_instance(self) -> 'outputs.GetInstanceTypesInstanceTypeBurstableInstanceResult':
        """
        The burstable instance attribution:
        """
        return pulumi.get(self, "burstable_instance")

    @property
    @pulumi.getter(name="cpuCoreCount")
    def cpu_core_count(self) -> float:
        """
        Filter the results to a specific number of cpu cores.
        """
        return pulumi.get(self, "cpu_core_count")

    @property
    @pulumi.getter(name="eniAmount")
    def eni_amount(self) -> float:
        """
        Filter the result whose network interface number is no more than `eni_amount`.
        """
        return pulumi.get(self, "eni_amount")

    @property
    @pulumi.getter
    def family(self) -> str:
        """
        The instance type family.
        """
        return pulumi.get(self, "family")

    @property
    @pulumi.getter
    def gpu(self) -> 'outputs.GetInstanceTypesInstanceTypeGpuResult':
        """
        The GPU attribution of an instance type:
        """
        return pulumi.get(self, "gpu")

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

    @property
    @pulumi.getter(name="localStorage")
    def local_storage(self) -> 'outputs.GetInstanceTypesInstanceTypeLocalStorageResult':
        """
        Local storage of an instance type:
        """
        return pulumi.get(self, "local_storage")

    @property
    @pulumi.getter(name="memorySize")
    def memory_size(self) -> float:
        """
        Filter the results to a specific memory size in GB.
        """
        return pulumi.get(self, "memory_size")

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


@pulumi.output_type
class GetInstanceTypesInstanceTypeBurstableInstanceResult(dict):
    def __init__(__self__, *,
                 baseline_credit: str,
                 initial_credit: str):
        """
        :param str baseline_credit: The compute performance benchmark CPU credit of a burstable instance.
        :param str initial_credit: The initial CPU credit of a burstable instance.
        """
        pulumi.set(__self__, "baseline_credit", baseline_credit)
        pulumi.set(__self__, "initial_credit", initial_credit)

    @property
    @pulumi.getter(name="baselineCredit")
    def baseline_credit(self) -> str:
        """
        The compute performance benchmark CPU credit of a burstable instance.
        """
        return pulumi.get(self, "baseline_credit")

    @property
    @pulumi.getter(name="initialCredit")
    def initial_credit(self) -> str:
        """
        The initial CPU credit of a burstable instance.
        """
        return pulumi.get(self, "initial_credit")


@pulumi.output_type
class GetInstanceTypesInstanceTypeGpuResult(dict):
    def __init__(__self__, *,
                 amount: str,
                 category: str):
        """
        :param str amount: The number of local storage devices that an instance has been attached to.
        :param str category: The category of local storage that an instance has been attached to.
        """
        pulumi.set(__self__, "amount", amount)
        pulumi.set(__self__, "category", category)

    @property
    @pulumi.getter
    def amount(self) -> str:
        """
        The number of local storage devices that an instance has been attached to.
        """
        return pulumi.get(self, "amount")

    @property
    @pulumi.getter
    def category(self) -> str:
        """
        The category of local storage that an instance has been attached to.
        """
        return pulumi.get(self, "category")


@pulumi.output_type
class GetInstanceTypesInstanceTypeLocalStorageResult(dict):
    def __init__(__self__, *,
                 amount: str,
                 capacity: str,
                 category: str):
        """
        :param str amount: The number of local storage devices that an instance has been attached to.
        :param str capacity: The capacity of a local storage in GB.
        :param str category: The category of local storage that an instance has been attached to.
        """
        pulumi.set(__self__, "amount", amount)
        pulumi.set(__self__, "capacity", capacity)
        pulumi.set(__self__, "category", category)

    @property
    @pulumi.getter
    def amount(self) -> str:
        """
        The number of local storage devices that an instance has been attached to.
        """
        return pulumi.get(self, "amount")

    @property
    @pulumi.getter
    def capacity(self) -> str:
        """
        The capacity of a local storage in GB.
        """
        return pulumi.get(self, "capacity")

    @property
    @pulumi.getter
    def category(self) -> str:
        """
        The category of local storage that an instance has been attached to.
        """
        return pulumi.get(self, "category")


@pulumi.output_type
class GetInstancesInstanceResult(dict):
    def __init__(__self__, *,
                 availability_zone: str,
                 creation_time: str,
                 description: str,
                 disk_device_mappings: List['outputs.GetInstancesInstanceDiskDeviceMappingResult'],
                 eip: str,
                 id: str,
                 image_id: str,
                 instance_charge_type: str,
                 instance_type: str,
                 internet_charge_type: str,
                 internet_max_bandwidth_out: float,
                 key_name: str,
                 name: str,
                 private_ip: str,
                 public_ip: str,
                 ram_role_name: str,
                 region_id: str,
                 resource_group_id: str,
                 security_groups: List[str],
                 spot_strategy: str,
                 status: str,
                 vpc_id: str,
                 vswitch_id: str,
                 tags: Optional[Mapping[str, Any]] = None):
        """
        :param str availability_zone: Availability zone where instances are located.
        :param str creation_time: Instance creation time.
        :param str description: Instance description.
        :param List['GetInstancesInstanceDiskDeviceMappingArgs'] disk_device_mappings: Description of the attached disks.
        :param str eip: EIP address the VPC instance is using.
        :param str id: ID of the instance.
        :param str image_id: The image ID of some ECS instance used.
        :param str instance_charge_type: Instance charge type.
        :param str instance_type: Instance type.
        :param str internet_charge_type: Instance network charge type.
        :param float internet_max_bandwidth_out: Max output bandwidth for internet.
        :param str key_name: Key pair the instance is using.
        :param str name: Instance name.
        :param str private_ip: Instance private IP address.
        :param str public_ip: Instance public IP address.
        :param str ram_role_name: The RAM role name which the instance attaches.
        :param str region_id: Region ID the instance belongs to.
        :param str resource_group_id: The Id of resource group which the instance belongs.
        :param List[str] security_groups: List of security group IDs the instance belongs to.
        :param str spot_strategy: Spot strategy the instance is using.
        :param str status: Instance status. Valid values: "Creating", "Starting", "Running", "Stopping" and "Stopped". If undefined, all statuses are considered.
        :param str vpc_id: ID of the VPC linked to the instances.
        :param str vswitch_id: ID of the VSwitch linked to the instances.
        :param Mapping[str, Any] tags: A map of tags assigned to the ECS instances. It must be in the format:
               ```python
               import pulumi
               import pulumi_alicloud as alicloud
               
               tagged_instances = alicloud.ecs.get_instances(tags={
                   "tagKey1": "tagValue1",
                   "tagKey2": "tagValue2",
               })
               ```
        """
        pulumi.set(__self__, "availability_zone", availability_zone)
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "disk_device_mappings", disk_device_mappings)
        pulumi.set(__self__, "eip", eip)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "image_id", image_id)
        pulumi.set(__self__, "instance_charge_type", instance_charge_type)
        pulumi.set(__self__, "instance_type", instance_type)
        pulumi.set(__self__, "internet_charge_type", internet_charge_type)
        pulumi.set(__self__, "internet_max_bandwidth_out", internet_max_bandwidth_out)
        pulumi.set(__self__, "key_name", key_name)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "private_ip", private_ip)
        pulumi.set(__self__, "public_ip", public_ip)
        pulumi.set(__self__, "ram_role_name", ram_role_name)
        pulumi.set(__self__, "region_id", region_id)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        pulumi.set(__self__, "security_groups", security_groups)
        pulumi.set(__self__, "spot_strategy", spot_strategy)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "vswitch_id", vswitch_id)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> str:
        """
        Availability zone where instances are located.
        """
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter(name="creationTime")
    def creation_time(self) -> str:
        """
        Instance creation time.
        """
        return pulumi.get(self, "creation_time")

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

    @property
    @pulumi.getter(name="diskDeviceMappings")
    def disk_device_mappings(self) -> List['outputs.GetInstancesInstanceDiskDeviceMappingResult']:
        """
        Description of the attached disks.
        """
        return pulumi.get(self, "disk_device_mappings")

    @property
    @pulumi.getter
    def eip(self) -> str:
        """
        EIP address the VPC instance is using.
        """
        return pulumi.get(self, "eip")

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

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> str:
        """
        The image ID of some ECS instance used.
        """
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="instanceChargeType")
    def instance_charge_type(self) -> str:
        """
        Instance charge type.
        """
        return pulumi.get(self, "instance_charge_type")

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

    @property
    @pulumi.getter(name="internetChargeType")
    def internet_charge_type(self) -> str:
        """
        Instance network charge type.
        """
        return pulumi.get(self, "internet_charge_type")

    @property
    @pulumi.getter(name="internetMaxBandwidthOut")
    def internet_max_bandwidth_out(self) -> float:
        """
        Max output bandwidth for internet.
        """
        return pulumi.get(self, "internet_max_bandwidth_out")

    @property
    @pulumi.getter(name="keyName")
    def key_name(self) -> str:
        """
        Key pair the instance is using.
        """
        return pulumi.get(self, "key_name")

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

    @property
    @pulumi.getter(name="privateIp")
    def private_ip(self) -> str:
        """
        Instance private IP address.
        """
        return pulumi.get(self, "private_ip")

    @property
    @pulumi.getter(name="publicIp")
    def public_ip(self) -> str:
        """
        Instance public IP address.
        """
        return pulumi.get(self, "public_ip")

    @property
    @pulumi.getter(name="ramRoleName")
    def ram_role_name(self) -> str:
        """
        The RAM role name which the instance attaches.
        """
        return pulumi.get(self, "ram_role_name")

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

    @property
    @pulumi.getter(name="resourceGroupId")
    def resource_group_id(self) -> str:
        """
        The Id of resource group which the instance belongs.
        """
        return pulumi.get(self, "resource_group_id")

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> List[str]:
        """
        List of security group IDs the instance belongs to.
        """
        return pulumi.get(self, "security_groups")

    @property
    @pulumi.getter(name="spotStrategy")
    def spot_strategy(self) -> str:
        """
        Spot strategy the instance is using.
        """
        return pulumi.get(self, "spot_strategy")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        Instance status. Valid values: "Creating", "Starting", "Running", "Stopping" and "Stopped". If undefined, all statuses are considered.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        ID of the VPC linked to the instances.
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter(name="vswitchId")
    def vswitch_id(self) -> str:
        """
        ID of the VSwitch linked to the instances.
        """
        return pulumi.get(self, "vswitch_id")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Mapping[str, Any]]:
        """
        A map of tags assigned to the ECS instances. It must be in the format:
        ```python
        import pulumi
        import pulumi_alicloud as alicloud

        tagged_instances = alicloud.ecs.get_instances(tags={
            "tagKey1": "tagValue1",
            "tagKey2": "tagValue2",
        })
        ```
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetInstancesInstanceDiskDeviceMappingResult(dict):
    def __init__(__self__, *,
                 category: str,
                 device: str,
                 size: float,
                 type: str):
        """
        :param str category: Cloud disk category.
        :param str device: Device information of the created disk: such as /dev/xvdb.
        :param float size: Size of the created disk.
        :param str type: Cloud disk type: system disk or data disk.
        """
        pulumi.set(__self__, "category", category)
        pulumi.set(__self__, "device", device)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def category(self) -> str:
        """
        Cloud disk category.
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter
    def device(self) -> str:
        """
        Device information of the created disk: such as /dev/xvdb.
        """
        return pulumi.get(self, "device")

    @property
    @pulumi.getter
    def size(self) -> float:
        """
        Size of the created disk.
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Cloud disk type: system disk or data disk.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetKeyPairsKeyPairResult(dict):
    def __init__(__self__, *,
                 finger_print: str,
                 id: str,
                 instances: List['outputs.GetKeyPairsKeyPairInstanceResult'],
                 key_name: str,
                 resource_group_id: str,
                 tags: Optional[Mapping[str, Any]] = None):
        """
        :param str finger_print: A finger print used to retrieve specified key pair.
        :param str id: ID of the key pair.
        :param List['GetKeyPairsKeyPairInstanceArgs'] instances: A list of ECS instances that has been bound this key pair.
        :param str key_name: Name of the key pair.
        :param str resource_group_id: The Id of resource group which the key pair belongs.
        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
        """
        pulumi.set(__self__, "finger_print", finger_print)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "instances", instances)
        pulumi.set(__self__, "key_name", key_name)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter(name="fingerPrint")
    def finger_print(self) -> str:
        """
        A finger print used to retrieve specified key pair.
        """
        return pulumi.get(self, "finger_print")

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

    @property
    @pulumi.getter
    def instances(self) -> List['outputs.GetKeyPairsKeyPairInstanceResult']:
        """
        A list of ECS instances that has been bound this key pair.
        """
        return pulumi.get(self, "instances")

    @property
    @pulumi.getter(name="keyName")
    def key_name(self) -> str:
        """
        Name of the key pair.
        """
        return pulumi.get(self, "key_name")

    @property
    @pulumi.getter(name="resourceGroupId")
    def resource_group_id(self) -> str:
        """
        The Id of resource group which the key pair belongs.
        """
        return pulumi.get(self, "resource_group_id")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Mapping[str, Any]]:
        """
        A mapping of tags to assign to the resource.
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetKeyPairsKeyPairInstanceResult(dict):
    def __init__(__self__, *,
                 availability_zone: str,
                 description: str,
                 image_id: str,
                 instance_id: str,
                 instance_name: str,
                 instance_type: str,
                 key_name: str,
                 private_ip: str,
                 public_ip: str,
                 region_id: str,
                 status: str,
                 vswitch_id: str):
        """
        :param str availability_zone: The ID of the availability zone where the ECS instance is located.
        :param str instance_id: The ID of the ECS instance.
        :param str instance_name: The name of the ECS instance.
        :param str key_name: Name of the key pair.
        :param str private_ip: The private IP address of the ECS instance.
        :param str public_ip: The public IP address or EIP of the ECS instance.
        :param str vswitch_id: The ID of the VSwitch attached to the ECS instance.
        """
        pulumi.set(__self__, "availability_zone", availability_zone)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "image_id", image_id)
        pulumi.set(__self__, "instance_id", instance_id)
        pulumi.set(__self__, "instance_name", instance_name)
        pulumi.set(__self__, "instance_type", instance_type)
        pulumi.set(__self__, "key_name", key_name)
        pulumi.set(__self__, "private_ip", private_ip)
        pulumi.set(__self__, "public_ip", public_ip)
        pulumi.set(__self__, "region_id", region_id)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "vswitch_id", vswitch_id)

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> str:
        """
        The ID of the availability zone where the ECS instance is located.
        """
        return pulumi.get(self, "availability_zone")

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

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

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> str:
        """
        The ID of the ECS instance.
        """
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter(name="instanceName")
    def instance_name(self) -> str:
        """
        The name of the ECS instance.
        """
        return pulumi.get(self, "instance_name")

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

    @property
    @pulumi.getter(name="keyName")
    def key_name(self) -> str:
        """
        Name of the key pair.
        """
        return pulumi.get(self, "key_name")

    @property
    @pulumi.getter(name="privateIp")
    def private_ip(self) -> str:
        """
        The private IP address of the ECS instance.
        """
        return pulumi.get(self, "private_ip")

    @property
    @pulumi.getter(name="publicIp")
    def public_ip(self) -> str:
        """
        The public IP address or EIP of the ECS instance.
        """
        return pulumi.get(self, "public_ip")

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

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

    @property
    @pulumi.getter(name="vswitchId")
    def vswitch_id(self) -> str:
        """
        The ID of the VSwitch attached to the ECS instance.
        """
        return pulumi.get(self, "vswitch_id")


@pulumi.output_type
class GetNetworkInterfacesInterfaceResult(dict):
    def __init__(__self__, *,
                 creation_time: str,
                 description: str,
                 id: str,
                 instance_id: str,
                 mac: str,
                 name: str,
                 private_ip: str,
                 private_ips: List[str],
                 public_ip: str,
                 resource_group_id: str,
                 security_groups: List[str],
                 status: str,
                 vpc_id: str,
                 vswitch_id: str,
                 zone_id: str,
                 tags: Optional[Mapping[str, Any]] = None):
        """
        :param str creation_time: Creation time of the ENI.
        :param str description: Description of the ENI.
        :param str id: ID of the ENI.
        :param str instance_id: ID of the instance that the ENI is attached to.
        :param str mac: MAC address of the ENI.
        :param str name: Name of the ENI.
        :param str private_ip: Primary private IP of the ENI.
        :param List[str] private_ips: A list of secondary private IP address that is assigned to the ENI.
        :param str public_ip: Public IP of the ENI.
        :param str resource_group_id: The Id of resource group.
        :param List[str] security_groups: A list of security group that the ENI belongs to.
        :param str status: Current status of the ENI.
        :param str vpc_id: ID of the VPC that the ENI belongs to.
        :param str vswitch_id: ID of the VSwitch that the ENI is linked to.
        :param str zone_id: ID of the availability zone that the ENI belongs to.
        :param Mapping[str, Any] tags: A map of tags assigned to the ENI.
        """
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "instance_id", instance_id)
        pulumi.set(__self__, "mac", mac)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "private_ip", private_ip)
        pulumi.set(__self__, "private_ips", private_ips)
        pulumi.set(__self__, "public_ip", public_ip)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        pulumi.set(__self__, "security_groups", security_groups)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "vswitch_id", vswitch_id)
        pulumi.set(__self__, "zone_id", zone_id)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

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

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

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

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> str:
        """
        ID of the instance that the ENI is attached to.
        """
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter
    def mac(self) -> str:
        """
        MAC address of the ENI.
        """
        return pulumi.get(self, "mac")

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

    @property
    @pulumi.getter(name="privateIp")
    def private_ip(self) -> str:
        """
        Primary private IP of the ENI.
        """
        return pulumi.get(self, "private_ip")

    @property
    @pulumi.getter(name="privateIps")
    def private_ips(self) -> List[str]:
        """
        A list of secondary private IP address that is assigned to the ENI.
        """
        return pulumi.get(self, "private_ips")

    @property
    @pulumi.getter(name="publicIp")
    def public_ip(self) -> str:
        """
        Public IP of the ENI.
        """
        return pulumi.get(self, "public_ip")

    @property
    @pulumi.getter(name="resourceGroupId")
    def resource_group_id(self) -> str:
        """
        The Id of resource group.
        """
        return pulumi.get(self, "resource_group_id")

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> List[str]:
        """
        A list of security group that the ENI belongs to.
        """
        return pulumi.get(self, "security_groups")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        Current status of the ENI.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        ID of the VPC that the ENI belongs to.
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter(name="vswitchId")
    def vswitch_id(self) -> str:
        """
        ID of the VSwitch that the ENI is linked to.
        """
        return pulumi.get(self, "vswitch_id")

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> str:
        """
        ID of the availability zone that the ENI belongs to.
        """
        return pulumi.get(self, "zone_id")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Mapping[str, Any]]:
        """
        A map of tags assigned to the ENI.
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetSecurityGroupRulesRuleResult(dict):
    def __init__(__self__, *,
                 description: str,
                 dest_cidr_ip: str,
                 dest_group_id: str,
                 dest_group_owner_account: str,
                 direction: str,
                 ip_protocol: str,
                 nic_type: str,
                 policy: str,
                 port_range: str,
                 priority: float,
                 source_cidr_ip: str,
                 source_group_id: str,
                 source_group_owner_account: str):
        """
        :param str description: The description of the rule.
        :param str dest_cidr_ip: Target IP address segment for egress authorization.
        :param str dest_group_id: Target security group id for ingress authorization.
        :param str dest_group_owner_account: Alibaba Cloud account of the target security group.
        :param str direction: Authorization direction. Valid values are: `ingress` or `egress`.
        :param str ip_protocol: The IP protocol. Valid values are: `tcp`, `udp`, `icmp`, `gre` and `all`.
        :param str nic_type: Refers to the network type. Can be either `internet` or `intranet`. The default value is `internet`.
        :param str policy: Authorization policy. Can be either `accept` or `drop`. The default value is `accept`.
        :param str port_range: The range of port numbers.
        :param float priority: Rule priority.
        :param str source_cidr_ip: Source IP address segment for ingress authorization.
        :param str source_group_id: Source security group ID for ingress authorization.
        :param str source_group_owner_account: Alibaba Cloud account of the source security group.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "dest_cidr_ip", dest_cidr_ip)
        pulumi.set(__self__, "dest_group_id", dest_group_id)
        pulumi.set(__self__, "dest_group_owner_account", dest_group_owner_account)
        pulumi.set(__self__, "direction", direction)
        pulumi.set(__self__, "ip_protocol", ip_protocol)
        pulumi.set(__self__, "nic_type", nic_type)
        pulumi.set(__self__, "policy", policy)
        pulumi.set(__self__, "port_range", port_range)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "source_cidr_ip", source_cidr_ip)
        pulumi.set(__self__, "source_group_id", source_group_id)
        pulumi.set(__self__, "source_group_owner_account", source_group_owner_account)

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

    @property
    @pulumi.getter(name="destCidrIp")
    def dest_cidr_ip(self) -> str:
        """
        Target IP address segment for egress authorization.
        """
        return pulumi.get(self, "dest_cidr_ip")

    @property
    @pulumi.getter(name="destGroupId")
    def dest_group_id(self) -> str:
        """
        Target security group id for ingress authorization.
        """
        return pulumi.get(self, "dest_group_id")

    @property
    @pulumi.getter(name="destGroupOwnerAccount")
    def dest_group_owner_account(self) -> str:
        """
        Alibaba Cloud account of the target security group.
        """
        return pulumi.get(self, "dest_group_owner_account")

    @property
    @pulumi.getter
    def direction(self) -> str:
        """
        Authorization direction. Valid values are: `ingress` or `egress`.
        """
        return pulumi.get(self, "direction")

    @property
    @pulumi.getter(name="ipProtocol")
    def ip_protocol(self) -> str:
        """
        The IP protocol. Valid values are: `tcp`, `udp`, `icmp`, `gre` and `all`.
        """
        return pulumi.get(self, "ip_protocol")

    @property
    @pulumi.getter(name="nicType")
    def nic_type(self) -> str:
        """
        Refers to the network type. Can be either `internet` or `intranet`. The default value is `internet`.
        """
        return pulumi.get(self, "nic_type")

    @property
    @pulumi.getter
    def policy(self) -> str:
        """
        Authorization policy. Can be either `accept` or `drop`. The default value is `accept`.
        """
        return pulumi.get(self, "policy")

    @property
    @pulumi.getter(name="portRange")
    def port_range(self) -> str:
        """
        The range of port numbers.
        """
        return pulumi.get(self, "port_range")

    @property
    @pulumi.getter
    def priority(self) -> float:
        """
        Rule priority.
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter(name="sourceCidrIp")
    def source_cidr_ip(self) -> str:
        """
        Source IP address segment for ingress authorization.
        """
        return pulumi.get(self, "source_cidr_ip")

    @property
    @pulumi.getter(name="sourceGroupId")
    def source_group_id(self) -> str:
        """
        Source security group ID for ingress authorization.
        """
        return pulumi.get(self, "source_group_id")

    @property
    @pulumi.getter(name="sourceGroupOwnerAccount")
    def source_group_owner_account(self) -> str:
        """
        Alibaba Cloud account of the source security group.
        """
        return pulumi.get(self, "source_group_owner_account")


@pulumi.output_type
class GetSecurityGroupsGroupResult(dict):
    def __init__(__self__, *,
                 creation_time: str,
                 description: str,
                 id: str,
                 inner_access: bool,
                 name: str,
                 resource_group_id: str,
                 security_group_type: str,
                 vpc_id: str,
                 tags: Optional[Mapping[str, Any]] = None):
        """
        :param str creation_time: Creation time of the security group.
        :param str description: The description of the security group.
        :param str id: The ID of the security group.
        :param bool inner_access: Whether to allow inner network access.
        :param str name: The name of the security group.
        :param str resource_group_id: The Id of resource group which the security_group belongs.
        :param str security_group_type: The type of the security group.
        :param str vpc_id: Used to retrieve security groups that belong to the specified VPC ID.
        :param Mapping[str, Any] tags: A map of tags assigned to the ECS instances. It must be in the format:
               ```python
               import pulumi
               import pulumi_alicloud as alicloud
               
               tagged_security_groups = alicloud.ecs.get_security_groups(tags={
                   "tagKey1": "tagValue1",
                   "tagKey2": "tagValue2",
               })
               ```
        """
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "inner_access", inner_access)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        pulumi.set(__self__, "security_group_type", security_group_type)
        pulumi.set(__self__, "vpc_id", vpc_id)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

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

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

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

    @property
    @pulumi.getter(name="innerAccess")
    def inner_access(self) -> bool:
        """
        Whether to allow inner network access.
        """
        return pulumi.get(self, "inner_access")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the security group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="resourceGroupId")
    def resource_group_id(self) -> str:
        """
        The Id of resource group which the security_group belongs.
        """
        return pulumi.get(self, "resource_group_id")

    @property
    @pulumi.getter(name="securityGroupType")
    def security_group_type(self) -> str:
        """
        The type of the security group.
        """
        return pulumi.get(self, "security_group_type")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        Used to retrieve security groups that belong to the specified VPC ID.
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Mapping[str, Any]]:
        """
        A map of tags assigned to the ECS instances. It must be in the format:
        ```python
        import pulumi
        import pulumi_alicloud as alicloud

        tagged_security_groups = alicloud.ecs.get_security_groups(tags={
            "tagKey1": "tagValue1",
            "tagKey2": "tagValue2",
        })
        ```
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetSnapshotsSnapshotResult(dict):
    def __init__(__self__, *,
                 creation_time: str,
                 description: str,
                 encrypted: bool,
                 id: str,
                 name: str,
                 product_code: str,
                 progress: str,
                 remain_time: float,
                 retention_days: float,
                 source_disk_id: str,
                 source_disk_size: str,
                 source_disk_type: str,
                 status: str,
                 usage: str,
                 tags: Optional[Mapping[str, Any]] = None):
        """
        :param str creation_time: Creation time. Time of creation. It is represented according to ISO8601, and UTC time is used. Format: YYYY-MM-DDThh:mmZ.
        :param str description: Description of the snapshot.
        :param bool encrypted: Whether the snapshot is encrypted or not.
        :param str id: ID of the snapshot.
        :param str name: Name of the snapshot.
        :param str product_code: Product code on the image market place.
        :param str progress: Progress of snapshot creation, presented in percentage.
        :param float remain_time: The remaining time of a snapshot creation task, in seconds.
        :param float retention_days: The number of days that an automatic snapshot retains in the console for your instance.
        :param str source_disk_id: Source disk ID, which is retained after the source disk of the snapshot is deleted.
        :param str source_disk_size: Size of the source disk, measured in GB.
        :param str source_disk_type: Source disk attribute. Value range: `System`,`Data`.
        :param str status: The snapshot status. Value range: `progressing`, `accomplished` and `failed`.
        :param str usage: Whether the snapshots are used to create resources or not. Value range: `image`, `disk`, `image_disk` and `none`.
        :param Mapping[str, Any] tags: A map of tags assigned to the snapshot.
        """
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "encrypted", encrypted)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "product_code", product_code)
        pulumi.set(__self__, "progress", progress)
        pulumi.set(__self__, "remain_time", remain_time)
        pulumi.set(__self__, "retention_days", retention_days)
        pulumi.set(__self__, "source_disk_id", source_disk_id)
        pulumi.set(__self__, "source_disk_size", source_disk_size)
        pulumi.set(__self__, "source_disk_type", source_disk_type)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "usage", usage)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter(name="creationTime")
    def creation_time(self) -> str:
        """
        Creation time. Time of creation. It is represented according to ISO8601, and UTC time is used. Format: YYYY-MM-DDThh:mmZ.
        """
        return pulumi.get(self, "creation_time")

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

    @property
    @pulumi.getter
    def encrypted(self) -> bool:
        """
        Whether the snapshot is encrypted or not.
        """
        return pulumi.get(self, "encrypted")

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

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

    @property
    @pulumi.getter(name="productCode")
    def product_code(self) -> str:
        """
        Product code on the image market place.
        """
        return pulumi.get(self, "product_code")

    @property
    @pulumi.getter
    def progress(self) -> str:
        """
        Progress of snapshot creation, presented in percentage.
        """
        return pulumi.get(self, "progress")

    @property
    @pulumi.getter(name="remainTime")
    def remain_time(self) -> float:
        """
        The remaining time of a snapshot creation task, in seconds.
        """
        return pulumi.get(self, "remain_time")

    @property
    @pulumi.getter(name="retentionDays")
    def retention_days(self) -> float:
        """
        The number of days that an automatic snapshot retains in the console for your instance.
        """
        return pulumi.get(self, "retention_days")

    @property
    @pulumi.getter(name="sourceDiskId")
    def source_disk_id(self) -> str:
        """
        Source disk ID, which is retained after the source disk of the snapshot is deleted.
        """
        return pulumi.get(self, "source_disk_id")

    @property
    @pulumi.getter(name="sourceDiskSize")
    def source_disk_size(self) -> str:
        """
        Size of the source disk, measured in GB.
        """
        return pulumi.get(self, "source_disk_size")

    @property
    @pulumi.getter(name="sourceDiskType")
    def source_disk_type(self) -> str:
        """
        Source disk attribute. Value range: `System`,`Data`.
        """
        return pulumi.get(self, "source_disk_type")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The snapshot status. Value range: `progressing`, `accomplished` and `failed`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter
    def usage(self) -> str:
        """
        Whether the snapshots are used to create resources or not. Value range: `image`, `disk`, `image_disk` and `none`.
        """
        return pulumi.get(self, "usage")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Mapping[str, Any]]:
        """
        A map of tags assigned to the snapshot.
        """
        return pulumi.get(self, "tags")


