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

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

__all__ = [
    'ImageDetectionResults',
    'ImageDetectionResultsItem',
    'ImageSnapshot',
    'ImageTag',
    'InstanceCpuMemory',
    'InstanceEipAddress',
    'InstanceImage',
    'InstanceKeyPair',
    'InstanceOperationSystem',
    'InstancePlacement',
    'InstancePrimaryNetworkInterface',
    'InstanceSecondaryNetworkInterface',
    'InstanceSystemVolume',
    'InstanceTag',
    'GetImageDetectionResultsResult',
    'GetImageDetectionResultsItemResult',
    'GetImageSnapshotResult',
    'GetImageTagResult',
    'GetInstanceCpuMemoryResult',
    'GetInstanceEipAddressResult',
    'GetInstanceImageResult',
    'GetInstanceKeyPairResult',
    'GetInstanceOperationSystemResult',
    'GetInstancePlacementResult',
    'GetInstancePrimaryNetworkInterfaceResult',
    'GetInstanceSecondaryNetworkInterfaceResult',
    'GetInstanceSystemVolumeResult',
    'GetInstanceTagResult',
]

@pulumi.output_type
class ImageDetectionResults(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "detectionStatus":
            suggest = "detection_status"

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

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

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

    def __init__(__self__, *,
                 detection_status: Optional[builtins.str] = None,
                 items: Optional[Sequence['outputs.ImageDetectionResultsItem']] = None):
        """
        :param builtins.str detection_status: 检测状态。可以选择Finished（已完成）、Processing（处理中）类型。
        """
        if detection_status is not None:
            pulumi.set(__self__, "detection_status", detection_status)
        if items is not None:
            pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter(name="detectionStatus")
    def detection_status(self) -> Optional[builtins.str]:
        """
        检测状态。可以选择Finished（已完成）、Processing（处理中）类型。
        """
        return pulumi.get(self, "detection_status")

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


@pulumi.output_type
class ImageDetectionResultsItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "riskCode":
            suggest = "risk_code"
        elif key == "riskLevel":
            suggest = "risk_level"

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

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

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

    def __init__(__self__, *,
                 name: Optional[builtins.str] = None,
                 result: Optional[builtins.str] = None,
                 risk_code: Optional[builtins.str] = None,
                 risk_level: Optional[builtins.str] = None):
        """
        :param builtins.str name: 检测项名称。
        :param builtins.str result: 该检测项对应结果。
        :param builtins.str risk_code: 风险描述码。
        :param builtins.str risk_level: 风险等级。若该参数返回值为空，表示无风险。
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if result is not None:
            pulumi.set(__self__, "result", result)
        if risk_code is not None:
            pulumi.set(__self__, "risk_code", risk_code)
        if risk_level is not None:
            pulumi.set(__self__, "risk_level", risk_level)

    @property
    @pulumi.getter
    def name(self) -> Optional[builtins.str]:
        """
        检测项名称。
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def result(self) -> Optional[builtins.str]:
        """
        该检测项对应结果。
        """
        return pulumi.get(self, "result")

    @property
    @pulumi.getter(name="riskCode")
    def risk_code(self) -> Optional[builtins.str]:
        """
        风险描述码。
        """
        return pulumi.get(self, "risk_code")

    @property
    @pulumi.getter(name="riskLevel")
    def risk_level(self) -> Optional[builtins.str]:
        """
        风险等级。若该参数返回值为空，表示无风险。
        """
        return pulumi.get(self, "risk_level")


@pulumi.output_type
class ImageSnapshot(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "snapshotId":
            suggest = "snapshot_id"
        elif key == "volumeKind":
            suggest = "volume_kind"

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

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

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

    def __init__(__self__, *,
                 size: Optional[builtins.int] = None,
                 snapshot_id: Optional[builtins.str] = None,
                 volume_kind: Optional[builtins.str] = None):
        """
        :param builtins.int size: 快照大小。单位为GiB。
        :param builtins.str snapshot_id: 快照ID。
        :param builtins.str volume_kind: 云盘种类。system：系统盘。data：数据盘。
        """
        if size is not None:
            pulumi.set(__self__, "size", size)
        if snapshot_id is not None:
            pulumi.set(__self__, "snapshot_id", snapshot_id)
        if volume_kind is not None:
            pulumi.set(__self__, "volume_kind", volume_kind)

    @property
    @pulumi.getter
    def size(self) -> Optional[builtins.int]:
        """
        快照大小。单位为GiB。
        """
        return pulumi.get(self, "size")

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

    @property
    @pulumi.getter(name="volumeKind")
    def volume_kind(self) -> Optional[builtins.str]:
        """
        云盘种类。system：系统盘。data：数据盘。
        """
        return pulumi.get(self, "volume_kind")


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

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

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


@pulumi.output_type
class InstanceCpuMemory(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "coreCount":
            suggest = "core_count"
        elif key == "cpuNumber":
            suggest = "cpu_number"
        elif key == "memorySize":
            suggest = "memory_size"
        elif key == "threadsPerCore":
            suggest = "threads_per_core"

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

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

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

    def __init__(__self__, *,
                 core_count: Optional[builtins.int] = None,
                 cpu_number: Optional[builtins.int] = None,
                 memory_size: Optional[builtins.int] = None,
                 threads_per_core: Optional[builtins.int] = None):
        """
        :param builtins.int core_count: 实例的核数。
        :param builtins.int cpu_number: 实例的CPU数量。
        :param builtins.int memory_size: 实例的内存大小，单位MB。
        :param builtins.int threads_per_core: 实例的每核线程数。
        """
        if core_count is not None:
            pulumi.set(__self__, "core_count", core_count)
        if cpu_number is not None:
            pulumi.set(__self__, "cpu_number", cpu_number)
        if memory_size is not None:
            pulumi.set(__self__, "memory_size", memory_size)
        if threads_per_core is not None:
            pulumi.set(__self__, "threads_per_core", threads_per_core)

    @property
    @pulumi.getter(name="coreCount")
    def core_count(self) -> Optional[builtins.int]:
        """
        实例的核数。
        """
        return pulumi.get(self, "core_count")

    @property
    @pulumi.getter(name="cpuNumber")
    def cpu_number(self) -> Optional[builtins.int]:
        """
        实例的CPU数量。
        """
        return pulumi.get(self, "cpu_number")

    @property
    @pulumi.getter(name="memorySize")
    def memory_size(self) -> Optional[builtins.int]:
        """
        实例的内存大小，单位MB。
        """
        return pulumi.get(self, "memory_size")

    @property
    @pulumi.getter(name="threadsPerCore")
    def threads_per_core(self) -> Optional[builtins.int]:
        """
        实例的每核线程数。
        """
        return pulumi.get(self, "threads_per_core")


@pulumi.output_type
class InstanceEipAddress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allocationId":
            suggest = "allocation_id"
        elif key == "bandwidthMbps":
            suggest = "bandwidth_mbps"
        elif key == "bandwidthPackageId":
            suggest = "bandwidth_package_id"
        elif key == "chargeType":
            suggest = "charge_type"
        elif key == "ipAddress":
            suggest = "ip_address"
        elif key == "releaseWithInstance":
            suggest = "release_with_instance"

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

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

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

    def __init__(__self__, *,
                 allocation_id: Optional[builtins.str] = None,
                 bandwidth_mbps: Optional[builtins.int] = None,
                 bandwidth_package_id: Optional[builtins.str] = None,
                 charge_type: Optional[builtins.str] = None,
                 ip_address: Optional[builtins.str] = None,
                 isp: Optional[builtins.str] = None,
                 release_with_instance: Optional[builtins.bool] = None):
        """
        :param builtins.str allocation_id: 实例的分配ID。
        :param builtins.int bandwidth_mbps: 公网IP的带宽上限，默认值为1，单位：Mbps。
                   - `ChargeType`传入`PayByBandwidth`：取值范围1～500。
                   - `ChargeType`传入`PayByTraffic`：取值范围1～200。
        :param builtins.str bandwidth_package_id: 共享带宽包的ID，表示将公网IP加入到共享带宽包。
                   - 您可以调用[DescribeBandwidthPackages](https://www.volcengine.com/docs/6623/100685)接口，查询共享带宽包的ID。
                   - 公网IP加入到共享带宽包必须同时满足如下条件：
                     - 二者的安全防护类型相同。
                     - 二者的地域相同。
                     - 公网IP的计费方式必须是按量计费。
                     - 共享带宽包为IPv4类型。
        :param builtins.str charge_type: 公网IP的计费方式，取值：
                   - PayByBandwidth（默认）：按量计费-按带宽上限计费。
                   - PayByTraffic：按量计费-按实际流量计费。
                   - PrePaid：包年包月。
                 
                 **提示:**
                 实例的计费类型`InstanceChargeType`取值为`PostPaid`时，该参数取值不能为`PrePaid`。
        :param builtins.str ip_address: 实例的IP地址。
        :param builtins.str isp: 公网IP的线路类型，默认为BGP。取值：
                   - BGP：BGP（多线）。
                   - 若您的账号已申请并开通了静态单线权限，则可传入如下取值：
                     - ChinaMobile：中国移动静态单线。
                     - ChinaTelecom：中国电信静态单线。
                     - ChinaUnicom：中国联通静态单线。
                   - 若您的账号已申请并开通了BGP单线权限，则可传入SingleLine_BGP。
                   - 若您的账号已申请并开通了静态BGP权限，则可传入Static_BGP。
        :param builtins.bool release_with_instance: 实例是否随实例释放。
        """
        if allocation_id is not None:
            pulumi.set(__self__, "allocation_id", allocation_id)
        if bandwidth_mbps is not None:
            pulumi.set(__self__, "bandwidth_mbps", bandwidth_mbps)
        if bandwidth_package_id is not None:
            pulumi.set(__self__, "bandwidth_package_id", bandwidth_package_id)
        if charge_type is not None:
            pulumi.set(__self__, "charge_type", charge_type)
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if isp is not None:
            pulumi.set(__self__, "isp", isp)
        if release_with_instance is not None:
            pulumi.set(__self__, "release_with_instance", release_with_instance)

    @property
    @pulumi.getter(name="allocationId")
    def allocation_id(self) -> Optional[builtins.str]:
        """
        实例的分配ID。
        """
        return pulumi.get(self, "allocation_id")

    @property
    @pulumi.getter(name="bandwidthMbps")
    def bandwidth_mbps(self) -> Optional[builtins.int]:
        """
        公网IP的带宽上限，默认值为1，单位：Mbps。
            - `ChargeType`传入`PayByBandwidth`：取值范围1～500。
            - `ChargeType`传入`PayByTraffic`：取值范围1～200。
        """
        return pulumi.get(self, "bandwidth_mbps")

    @property
    @pulumi.getter(name="bandwidthPackageId")
    def bandwidth_package_id(self) -> Optional[builtins.str]:
        """
        共享带宽包的ID，表示将公网IP加入到共享带宽包。
            - 您可以调用[DescribeBandwidthPackages](https://www.volcengine.com/docs/6623/100685)接口，查询共享带宽包的ID。
            - 公网IP加入到共享带宽包必须同时满足如下条件：
              - 二者的安全防护类型相同。
              - 二者的地域相同。
              - 公网IP的计费方式必须是按量计费。
              - 共享带宽包为IPv4类型。
        """
        return pulumi.get(self, "bandwidth_package_id")

    @property
    @pulumi.getter(name="chargeType")
    def charge_type(self) -> Optional[builtins.str]:
        """
        公网IP的计费方式，取值：
            - PayByBandwidth（默认）：按量计费-按带宽上限计费。
            - PayByTraffic：按量计费-按实际流量计费。
            - PrePaid：包年包月。
          
          **提示:**
          实例的计费类型`InstanceChargeType`取值为`PostPaid`时，该参数取值不能为`PrePaid`。
        """
        return pulumi.get(self, "charge_type")

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[builtins.str]:
        """
        实例的IP地址。
        """
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter
    def isp(self) -> Optional[builtins.str]:
        """
        公网IP的线路类型，默认为BGP。取值：
            - BGP：BGP（多线）。
            - 若您的账号已申请并开通了静态单线权限，则可传入如下取值：
              - ChinaMobile：中国移动静态单线。
              - ChinaTelecom：中国电信静态单线。
              - ChinaUnicom：中国联通静态单线。
            - 若您的账号已申请并开通了BGP单线权限，则可传入SingleLine_BGP。
            - 若您的账号已申请并开通了静态BGP权限，则可传入Static_BGP。
        """
        return pulumi.get(self, "isp")

    @property
    @pulumi.getter(name="releaseWithInstance")
    def release_with_instance(self) -> Optional[builtins.bool]:
        """
        实例是否随实例释放。
        """
        return pulumi.get(self, "release_with_instance")


@pulumi.output_type
class InstanceImage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "imageId":
            suggest = "image_id"
        elif key == "imageReleaseVersion":
            suggest = "image_release_version"
        elif key == "keepImageCredential":
            suggest = "keep_image_credential"
        elif key == "securityEnhancementStrategy":
            suggest = "security_enhancement_strategy"

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

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

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

    def __init__(__self__, *,
                 image_id: builtins.str,
                 image_release_version: Optional[builtins.str] = None,
                 keep_image_credential: Optional[builtins.bool] = None,
                 security_enhancement_strategy: Optional[builtins.str] = None):
        """
        :param builtins.str image_id: 实例的镜像ID。
        :param builtins.str image_release_version: 实例的镜像发布版本。
        :param builtins.bool keep_image_credential: 实例是否保留镜像凭证。
        :param builtins.str security_enhancement_strategy: 实例的安全增强策略。Active：开启安全加固，仅对公共镜像生效。InActive：关闭安全加固，对所有镜像生效。
        """
        pulumi.set(__self__, "image_id", image_id)
        if image_release_version is not None:
            pulumi.set(__self__, "image_release_version", image_release_version)
        if keep_image_credential is not None:
            pulumi.set(__self__, "keep_image_credential", keep_image_credential)
        if security_enhancement_strategy is not None:
            pulumi.set(__self__, "security_enhancement_strategy", security_enhancement_strategy)

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> builtins.str:
        """
        实例的镜像ID。
        """
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="imageReleaseVersion")
    def image_release_version(self) -> Optional[builtins.str]:
        """
        实例的镜像发布版本。
        """
        return pulumi.get(self, "image_release_version")

    @property
    @pulumi.getter(name="keepImageCredential")
    def keep_image_credential(self) -> Optional[builtins.bool]:
        """
        实例是否保留镜像凭证。
        """
        return pulumi.get(self, "keep_image_credential")

    @property
    @pulumi.getter(name="securityEnhancementStrategy")
    def security_enhancement_strategy(self) -> Optional[builtins.str]:
        """
        实例的安全增强策略。Active：开启安全加固，仅对公共镜像生效。InActive：关闭安全加固，对所有镜像生效。
        """
        return pulumi.get(self, "security_enhancement_strategy")


@pulumi.output_type
class InstanceKeyPair(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyPairId":
            suggest = "key_pair_id"
        elif key == "keyPairName":
            suggest = "key_pair_name"

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

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

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

    def __init__(__self__, *,
                 key_pair_id: Optional[builtins.str] = None,
                 key_pair_name: Optional[builtins.str] = None):
        """
        :param builtins.str key_pair_id: 实例的公钥。
        :param builtins.str key_pair_name: 实例的密钥对名称。
        """
        if key_pair_id is not None:
            pulumi.set(__self__, "key_pair_id", key_pair_id)
        if key_pair_name is not None:
            pulumi.set(__self__, "key_pair_name", key_pair_name)

    @property
    @pulumi.getter(name="keyPairId")
    def key_pair_id(self) -> Optional[builtins.str]:
        """
        实例的公钥。
        """
        return pulumi.get(self, "key_pair_id")

    @property
    @pulumi.getter(name="keyPairName")
    def key_pair_name(self) -> Optional[builtins.str]:
        """
        实例的密钥对名称。
        """
        return pulumi.get(self, "key_pair_name")


@pulumi.output_type
class InstanceOperationSystem(dict):
    def __init__(__self__, *,
                 name: Optional[builtins.str] = None,
                 type: Optional[builtins.str] = None):
        """
        :param builtins.str name: 实例的操作系统名称。
        :param builtins.str type: 实例的操作系统类型。Linux：Linux系统。Windows：Windows系统。
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def name(self) -> Optional[builtins.str]:
        """
        实例的操作系统名称。
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def type(self) -> Optional[builtins.str]:
        """
        实例的操作系统类型。Linux：Linux系统。Windows：Windows系统。
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class InstancePlacement(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dedicatedHostClusterId":
            suggest = "dedicated_host_cluster_id"
        elif key == "dedicatedHostId":
            suggest = "dedicated_host_id"

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

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

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

    def __init__(__self__, *,
                 affinity: Optional[builtins.str] = None,
                 dedicated_host_cluster_id: Optional[builtins.str] = None,
                 dedicated_host_id: Optional[builtins.str] = None,
                 tenancy: Optional[builtins.str] = None):
        """
        :param builtins.str affinity: 针对节省停机模式的ECS实例，停止后会释放部分资源，本参数用于查看ECS实例重新启动时是否仍固定部署在原宿主机上。取值：Host：启用节省停机模式的实例重新启动时，仍会部署在原宿主机上。Default（默认）：启用节省停机模式的实例重新启动时，会优先迁移到支持自动部署的宿主机；若支持自动部署的宿主机资源不足，则在原宿主机上进行启动。
        :param builtins.str dedicated_host_cluster_id: 实例的专用主机集群ID。
        :param builtins.str dedicated_host_id: 实例的专用主机ID。
        :param builtins.str tenancy: 是否在专有宿主机上创建实例，取值：Default（默认）：创建普通云服务器实例。Host：创建专有宿主机实例。若您不指定DedicatedHostId，则由系统自动选择专有宿主机放置实例
        """
        if affinity is not None:
            pulumi.set(__self__, "affinity", affinity)
        if dedicated_host_cluster_id is not None:
            pulumi.set(__self__, "dedicated_host_cluster_id", dedicated_host_cluster_id)
        if dedicated_host_id is not None:
            pulumi.set(__self__, "dedicated_host_id", dedicated_host_id)
        if tenancy is not None:
            pulumi.set(__self__, "tenancy", tenancy)

    @property
    @pulumi.getter
    def affinity(self) -> Optional[builtins.str]:
        """
        针对节省停机模式的ECS实例，停止后会释放部分资源，本参数用于查看ECS实例重新启动时是否仍固定部署在原宿主机上。取值：Host：启用节省停机模式的实例重新启动时，仍会部署在原宿主机上。Default（默认）：启用节省停机模式的实例重新启动时，会优先迁移到支持自动部署的宿主机；若支持自动部署的宿主机资源不足，则在原宿主机上进行启动。
        """
        return pulumi.get(self, "affinity")

    @property
    @pulumi.getter(name="dedicatedHostClusterId")
    def dedicated_host_cluster_id(self) -> Optional[builtins.str]:
        """
        实例的专用主机集群ID。
        """
        return pulumi.get(self, "dedicated_host_cluster_id")

    @property
    @pulumi.getter(name="dedicatedHostId")
    def dedicated_host_id(self) -> Optional[builtins.str]:
        """
        实例的专用主机ID。
        """
        return pulumi.get(self, "dedicated_host_id")

    @property
    @pulumi.getter
    def tenancy(self) -> Optional[builtins.str]:
        """
        是否在专有宿主机上创建实例，取值：Default（默认）：创建普通云服务器实例。Host：创建专有宿主机实例。若您不指定DedicatedHostId，则由系统自动选择专有宿主机放置实例
        """
        return pulumi.get(self, "tenancy")


@pulumi.output_type
class InstancePrimaryNetworkInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "securityGroupIds":
            suggest = "security_group_ids"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "ipv6AddressCount":
            suggest = "ipv6_address_count"
        elif key == "ipv6Addresses":
            suggest = "ipv6_addresses"
        elif key == "macAddress":
            suggest = "mac_address"
        elif key == "networkInterfaceId":
            suggest = "network_interface_id"
        elif key == "primaryIpAddress":
            suggest = "primary_ip_address"
        elif key == "privateIpAddresses":
            suggest = "private_ip_addresses"
        elif key == "vpcId":
            suggest = "vpc_id"

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

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

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

    def __init__(__self__, *,
                 security_group_ids: Sequence[builtins.str],
                 subnet_id: builtins.str,
                 ipv6_address_count: Optional[builtins.int] = None,
                 ipv6_addresses: Optional[Sequence[builtins.str]] = None,
                 mac_address: Optional[builtins.str] = None,
                 network_interface_id: Optional[builtins.str] = None,
                 primary_ip_address: Optional[builtins.str] = None,
                 private_ip_addresses: Optional[Sequence[builtins.str]] = None,
                 vpc_id: Optional[builtins.str] = None):
        """
        :param Sequence[builtins.str] security_group_ids: 实例的安全组ID。
        :param builtins.str subnet_id: 实例的子网ID。
        :param builtins.int ipv6_address_count: 实例的IPv6地址数量。
        :param Sequence[builtins.str] ipv6_addresses: 实例的IPv6地址。
        :param builtins.str mac_address: 实例的MAC地址。
        :param builtins.str network_interface_id: 实例的网络接口ID。
        :param builtins.str primary_ip_address: 实例的主IP地址。
        :param Sequence[builtins.str] private_ip_addresses: 实例的私有IP地址。
        :param builtins.str vpc_id: 实例的VPC ID。
        """
        pulumi.set(__self__, "security_group_ids", security_group_ids)
        pulumi.set(__self__, "subnet_id", subnet_id)
        if ipv6_address_count is not None:
            pulumi.set(__self__, "ipv6_address_count", ipv6_address_count)
        if ipv6_addresses is not None:
            pulumi.set(__self__, "ipv6_addresses", ipv6_addresses)
        if mac_address is not None:
            pulumi.set(__self__, "mac_address", mac_address)
        if network_interface_id is not None:
            pulumi.set(__self__, "network_interface_id", network_interface_id)
        if primary_ip_address is not None:
            pulumi.set(__self__, "primary_ip_address", primary_ip_address)
        if private_ip_addresses is not None:
            pulumi.set(__self__, "private_ip_addresses", private_ip_addresses)
        if vpc_id is not None:
            pulumi.set(__self__, "vpc_id", vpc_id)

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> Sequence[builtins.str]:
        """
        实例的安全组ID。
        """
        return pulumi.get(self, "security_group_ids")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        """
        实例的子网ID。
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="ipv6AddressCount")
    def ipv6_address_count(self) -> Optional[builtins.int]:
        """
        实例的IPv6地址数量。
        """
        return pulumi.get(self, "ipv6_address_count")

    @property
    @pulumi.getter(name="ipv6Addresses")
    def ipv6_addresses(self) -> Optional[Sequence[builtins.str]]:
        """
        实例的IPv6地址。
        """
        return pulumi.get(self, "ipv6_addresses")

    @property
    @pulumi.getter(name="macAddress")
    def mac_address(self) -> Optional[builtins.str]:
        """
        实例的MAC地址。
        """
        return pulumi.get(self, "mac_address")

    @property
    @pulumi.getter(name="networkInterfaceId")
    def network_interface_id(self) -> Optional[builtins.str]:
        """
        实例的网络接口ID。
        """
        return pulumi.get(self, "network_interface_id")

    @property
    @pulumi.getter(name="primaryIpAddress")
    def primary_ip_address(self) -> Optional[builtins.str]:
        """
        实例的主IP地址。
        """
        return pulumi.get(self, "primary_ip_address")

    @property
    @pulumi.getter(name="privateIpAddresses")
    def private_ip_addresses(self) -> Optional[Sequence[builtins.str]]:
        """
        实例的私有IP地址。
        """
        return pulumi.get(self, "private_ip_addresses")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> Optional[builtins.str]:
        """
        实例的VPC ID。
        """
        return pulumi.get(self, "vpc_id")


@pulumi.output_type
class InstanceSecondaryNetworkInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipv6AddressCount":
            suggest = "ipv6_address_count"
        elif key == "primaryIpAddress":
            suggest = "primary_ip_address"
        elif key == "privateIpAddresses":
            suggest = "private_ip_addresses"
        elif key == "securityGroupIds":
            suggest = "security_group_ids"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "vpcId":
            suggest = "vpc_id"

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

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

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

    def __init__(__self__, *,
                 ipv6_address_count: Optional[builtins.int] = None,
                 primary_ip_address: Optional[builtins.str] = None,
                 private_ip_addresses: Optional[Sequence[builtins.str]] = None,
                 security_group_ids: Optional[Sequence[builtins.str]] = None,
                 subnet_id: Optional[builtins.str] = None,
                 vpc_id: Optional[builtins.str] = None):
        """
        :param builtins.int ipv6_address_count: 实例的IPv6地址数量。
        :param builtins.str primary_ip_address: 实例的主IP地址。
        :param Sequence[builtins.str] private_ip_addresses: 实例的私有IP地址。
        :param Sequence[builtins.str] security_group_ids: 实例的安全组ID。
        :param builtins.str subnet_id: 实例的子网ID。
        :param builtins.str vpc_id: 实例的VPC ID。
        """
        if ipv6_address_count is not None:
            pulumi.set(__self__, "ipv6_address_count", ipv6_address_count)
        if primary_ip_address is not None:
            pulumi.set(__self__, "primary_ip_address", primary_ip_address)
        if private_ip_addresses is not None:
            pulumi.set(__self__, "private_ip_addresses", private_ip_addresses)
        if security_group_ids is not None:
            pulumi.set(__self__, "security_group_ids", security_group_ids)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if vpc_id is not None:
            pulumi.set(__self__, "vpc_id", vpc_id)

    @property
    @pulumi.getter(name="ipv6AddressCount")
    def ipv6_address_count(self) -> Optional[builtins.int]:
        """
        实例的IPv6地址数量。
        """
        return pulumi.get(self, "ipv6_address_count")

    @property
    @pulumi.getter(name="primaryIpAddress")
    def primary_ip_address(self) -> Optional[builtins.str]:
        """
        实例的主IP地址。
        """
        return pulumi.get(self, "primary_ip_address")

    @property
    @pulumi.getter(name="privateIpAddresses")
    def private_ip_addresses(self) -> Optional[Sequence[builtins.str]]:
        """
        实例的私有IP地址。
        """
        return pulumi.get(self, "private_ip_addresses")

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> Optional[Sequence[builtins.str]]:
        """
        实例的安全组ID。
        """
        return pulumi.get(self, "security_group_ids")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[builtins.str]:
        """
        实例的子网ID。
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> Optional[builtins.str]:
        """
        实例的VPC ID。
        """
        return pulumi.get(self, "vpc_id")


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

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

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

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

    def __init__(__self__, *,
                 delete_with_instance: Optional[builtins.bool] = None,
                 extra_performance_iops: Optional[builtins.int] = None,
                 extra_performance_throughput_mb: Optional[builtins.int] = None,
                 extra_performance_type_id: Optional[builtins.str] = None,
                 size: Optional[builtins.int] = None,
                 snapshot_id: Optional[builtins.str] = None,
                 volume_id: Optional[builtins.str] = None,
                 volume_type: Optional[builtins.str] = None):
        """
        :param builtins.bool delete_with_instance: 实例是否随实例删除。
        :param builtins.int extra_performance_iops: 实例的额外性能IOPS。
        :param builtins.int extra_performance_throughput_mb: 实例的额外性能吞吐量，单位MB。
        :param builtins.str extra_performance_type_id: 额外性能的类型，取值如下：Balance：均衡型额外性能。IOPS：IOPS型额外性能。Throughput：吞吐量型额外性能。
        :param builtins.int size: 实例的大小，单位GiB。
        :param builtins.str snapshot_id: 实例的快照ID。
        :param builtins.str volume_id: 实例的卷ID。
        :param builtins.str volume_type: 云盘类型，取值说明如下：PTSSD：性能型SSD。ESSD_PL0：极速型SSD云盘，PL0规格。ESSD_FlexPL: 极速型SSD云盘，FlexPL规格。TSSD_TL0：吞吐型SSD云盘。
        """
        if delete_with_instance is not None:
            pulumi.set(__self__, "delete_with_instance", delete_with_instance)
        if extra_performance_iops is not None:
            pulumi.set(__self__, "extra_performance_iops", extra_performance_iops)
        if extra_performance_throughput_mb is not None:
            pulumi.set(__self__, "extra_performance_throughput_mb", extra_performance_throughput_mb)
        if extra_performance_type_id is not None:
            pulumi.set(__self__, "extra_performance_type_id", extra_performance_type_id)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if snapshot_id is not None:
            pulumi.set(__self__, "snapshot_id", snapshot_id)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter(name="deleteWithInstance")
    def delete_with_instance(self) -> Optional[builtins.bool]:
        """
        实例是否随实例删除。
        """
        return pulumi.get(self, "delete_with_instance")

    @property
    @pulumi.getter(name="extraPerformanceIops")
    def extra_performance_iops(self) -> Optional[builtins.int]:
        """
        实例的额外性能IOPS。
        """
        return pulumi.get(self, "extra_performance_iops")

    @property
    @pulumi.getter(name="extraPerformanceThroughputMb")
    def extra_performance_throughput_mb(self) -> Optional[builtins.int]:
        """
        实例的额外性能吞吐量，单位MB。
        """
        return pulumi.get(self, "extra_performance_throughput_mb")

    @property
    @pulumi.getter(name="extraPerformanceTypeId")
    def extra_performance_type_id(self) -> Optional[builtins.str]:
        """
        额外性能的类型，取值如下：Balance：均衡型额外性能。IOPS：IOPS型额外性能。Throughput：吞吐量型额外性能。
        """
        return pulumi.get(self, "extra_performance_type_id")

    @property
    @pulumi.getter
    def size(self) -> Optional[builtins.int]:
        """
        实例的大小，单位GiB。
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="snapshotId")
    def snapshot_id(self) -> Optional[builtins.str]:
        """
        实例的快照ID。
        """
        return pulumi.get(self, "snapshot_id")

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[builtins.str]:
        """
        实例的卷ID。
        """
        return pulumi.get(self, "volume_id")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[builtins.str]:
        """
        云盘类型，取值说明如下：PTSSD：性能型SSD。ESSD_PL0：极速型SSD云盘，PL0规格。ESSD_FlexPL: 极速型SSD云盘，FlexPL规格。TSSD_TL0：吞吐型SSD云盘。
        """
        return pulumi.get(self, "volume_type")


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

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

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


@pulumi.output_type
class GetImageDetectionResultsResult(dict):
    def __init__(__self__, *,
                 detection_status: builtins.str,
                 items: Sequence['outputs.GetImageDetectionResultsItemResult']):
        """
        :param builtins.str detection_status: 检测状态。可以选择Finished（已完成）、Processing（处理中）类型。
        :param Sequence['GetImageDetectionResultsItemArgs'] items: 镜像检测项详情。
        """
        pulumi.set(__self__, "detection_status", detection_status)
        pulumi.set(__self__, "items", items)

    @property
    @pulumi.getter(name="detectionStatus")
    def detection_status(self) -> builtins.str:
        """
        检测状态。可以选择Finished（已完成）、Processing（处理中）类型。
        """
        return pulumi.get(self, "detection_status")

    @property
    @pulumi.getter
    def items(self) -> Sequence['outputs.GetImageDetectionResultsItemResult']:
        """
        镜像检测项详情。
        """
        return pulumi.get(self, "items")


@pulumi.output_type
class GetImageDetectionResultsItemResult(dict):
    def __init__(__self__, *,
                 name: builtins.str,
                 result: builtins.str,
                 risk_code: builtins.str,
                 risk_level: builtins.str):
        """
        :param builtins.str name: 检测项名称。
        :param builtins.str result: 该检测项对应结果。
        :param builtins.str risk_code: 风险描述码。
        :param builtins.str risk_level: 风险等级。若该参数返回值为空，表示无风险。
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "result", result)
        pulumi.set(__self__, "risk_code", risk_code)
        pulumi.set(__self__, "risk_level", risk_level)

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        检测项名称。
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def result(self) -> builtins.str:
        """
        该检测项对应结果。
        """
        return pulumi.get(self, "result")

    @property
    @pulumi.getter(name="riskCode")
    def risk_code(self) -> builtins.str:
        """
        风险描述码。
        """
        return pulumi.get(self, "risk_code")

    @property
    @pulumi.getter(name="riskLevel")
    def risk_level(self) -> builtins.str:
        """
        风险等级。若该参数返回值为空，表示无风险。
        """
        return pulumi.get(self, "risk_level")


@pulumi.output_type
class GetImageSnapshotResult(dict):
    def __init__(__self__, *,
                 size: builtins.int,
                 snapshot_id: builtins.str,
                 volume_kind: builtins.str):
        """
        :param builtins.int size: 快照大小。单位为GiB。
        :param builtins.str snapshot_id: 快照ID。
        :param builtins.str volume_kind: 云盘种类。system：系统盘。data：数据盘。
        """
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "snapshot_id", snapshot_id)
        pulumi.set(__self__, "volume_kind", volume_kind)

    @property
    @pulumi.getter
    def size(self) -> builtins.int:
        """
        快照大小。单位为GiB。
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="snapshotId")
    def snapshot_id(self) -> builtins.str:
        """
        快照ID。
        """
        return pulumi.get(self, "snapshot_id")

    @property
    @pulumi.getter(name="volumeKind")
    def volume_kind(self) -> builtins.str:
        """
        云盘种类。system：系统盘。data：数据盘。
        """
        return pulumi.get(self, "volume_kind")


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

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

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


@pulumi.output_type
class GetInstanceCpuMemoryResult(dict):
    def __init__(__self__, *,
                 core_count: builtins.int,
                 cpu_number: builtins.int,
                 memory_size: builtins.int,
                 threads_per_core: builtins.int):
        """
        :param builtins.int core_count: 实例的核数。
        :param builtins.int cpu_number: 实例的CPU数量。
        :param builtins.int memory_size: 实例的内存大小，单位MB。
        :param builtins.int threads_per_core: 实例的每核线程数。
        """
        pulumi.set(__self__, "core_count", core_count)
        pulumi.set(__self__, "cpu_number", cpu_number)
        pulumi.set(__self__, "memory_size", memory_size)
        pulumi.set(__self__, "threads_per_core", threads_per_core)

    @property
    @pulumi.getter(name="coreCount")
    def core_count(self) -> builtins.int:
        """
        实例的核数。
        """
        return pulumi.get(self, "core_count")

    @property
    @pulumi.getter(name="cpuNumber")
    def cpu_number(self) -> builtins.int:
        """
        实例的CPU数量。
        """
        return pulumi.get(self, "cpu_number")

    @property
    @pulumi.getter(name="memorySize")
    def memory_size(self) -> builtins.int:
        """
        实例的内存大小，单位MB。
        """
        return pulumi.get(self, "memory_size")

    @property
    @pulumi.getter(name="threadsPerCore")
    def threads_per_core(self) -> builtins.int:
        """
        实例的每核线程数。
        """
        return pulumi.get(self, "threads_per_core")


@pulumi.output_type
class GetInstanceEipAddressResult(dict):
    def __init__(__self__, *,
                 allocation_id: builtins.str,
                 bandwidth_mbps: builtins.int,
                 bandwidth_package_id: builtins.str,
                 charge_type: builtins.str,
                 ip_address: builtins.str,
                 isp: builtins.str,
                 release_with_instance: builtins.bool):
        """
        :param builtins.str allocation_id: 实例的分配ID。
        :param builtins.int bandwidth_mbps: 公网IP的带宽上限，默认值为1，单位：Mbps。
                   - `ChargeType`传入`PayByBandwidth`：取值范围1～500。
                   - `ChargeType`传入`PayByTraffic`：取值范围1～200。
        :param builtins.str bandwidth_package_id: 共享带宽包的ID，表示将公网IP加入到共享带宽包。
                   - 您可以调用[DescribeBandwidthPackages](https://www.volcengine.com/docs/6623/100685)接口，查询共享带宽包的ID。
                   - 公网IP加入到共享带宽包必须同时满足如下条件：
                     - 二者的安全防护类型相同。
                     - 二者的地域相同。
                     - 公网IP的计费方式必须是按量计费。
                     - 共享带宽包为IPv4类型。
        :param builtins.str charge_type: 公网IP的计费方式，取值：
                   - PayByBandwidth（默认）：按量计费-按带宽上限计费。
                   - PayByTraffic：按量计费-按实际流量计费。
                   - PrePaid：包年包月。
                 
                 **提示:**
                 实例的计费类型`InstanceChargeType`取值为`PostPaid`时，该参数取值不能为`PrePaid`。
        :param builtins.str ip_address: 实例的IP地址。
        :param builtins.str isp: 公网IP的线路类型，默认为BGP。取值：
                   - BGP：BGP（多线）。
                   - 若您的账号已申请并开通了静态单线权限，则可传入如下取值：
                     - ChinaMobile：中国移动静态单线。
                     - ChinaTelecom：中国电信静态单线。
                     - ChinaUnicom：中国联通静态单线。
                   - 若您的账号已申请并开通了BGP单线权限，则可传入SingleLine_BGP。
                   - 若您的账号已申请并开通了静态BGP权限，则可传入Static_BGP。
        :param builtins.bool release_with_instance: 实例是否随实例释放。
        """
        pulumi.set(__self__, "allocation_id", allocation_id)
        pulumi.set(__self__, "bandwidth_mbps", bandwidth_mbps)
        pulumi.set(__self__, "bandwidth_package_id", bandwidth_package_id)
        pulumi.set(__self__, "charge_type", charge_type)
        pulumi.set(__self__, "ip_address", ip_address)
        pulumi.set(__self__, "isp", isp)
        pulumi.set(__self__, "release_with_instance", release_with_instance)

    @property
    @pulumi.getter(name="allocationId")
    def allocation_id(self) -> builtins.str:
        """
        实例的分配ID。
        """
        return pulumi.get(self, "allocation_id")

    @property
    @pulumi.getter(name="bandwidthMbps")
    def bandwidth_mbps(self) -> builtins.int:
        """
        公网IP的带宽上限，默认值为1，单位：Mbps。
            - `ChargeType`传入`PayByBandwidth`：取值范围1～500。
            - `ChargeType`传入`PayByTraffic`：取值范围1～200。
        """
        return pulumi.get(self, "bandwidth_mbps")

    @property
    @pulumi.getter(name="bandwidthPackageId")
    def bandwidth_package_id(self) -> builtins.str:
        """
        共享带宽包的ID，表示将公网IP加入到共享带宽包。
            - 您可以调用[DescribeBandwidthPackages](https://www.volcengine.com/docs/6623/100685)接口，查询共享带宽包的ID。
            - 公网IP加入到共享带宽包必须同时满足如下条件：
              - 二者的安全防护类型相同。
              - 二者的地域相同。
              - 公网IP的计费方式必须是按量计费。
              - 共享带宽包为IPv4类型。
        """
        return pulumi.get(self, "bandwidth_package_id")

    @property
    @pulumi.getter(name="chargeType")
    def charge_type(self) -> builtins.str:
        """
        公网IP的计费方式，取值：
            - PayByBandwidth（默认）：按量计费-按带宽上限计费。
            - PayByTraffic：按量计费-按实际流量计费。
            - PrePaid：包年包月。
          
          **提示:**
          实例的计费类型`InstanceChargeType`取值为`PostPaid`时，该参数取值不能为`PrePaid`。
        """
        return pulumi.get(self, "charge_type")

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> builtins.str:
        """
        实例的IP地址。
        """
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter
    def isp(self) -> builtins.str:
        """
        公网IP的线路类型，默认为BGP。取值：
            - BGP：BGP（多线）。
            - 若您的账号已申请并开通了静态单线权限，则可传入如下取值：
              - ChinaMobile：中国移动静态单线。
              - ChinaTelecom：中国电信静态单线。
              - ChinaUnicom：中国联通静态单线。
            - 若您的账号已申请并开通了BGP单线权限，则可传入SingleLine_BGP。
            - 若您的账号已申请并开通了静态BGP权限，则可传入Static_BGP。
        """
        return pulumi.get(self, "isp")

    @property
    @pulumi.getter(name="releaseWithInstance")
    def release_with_instance(self) -> builtins.bool:
        """
        实例是否随实例释放。
        """
        return pulumi.get(self, "release_with_instance")


@pulumi.output_type
class GetInstanceImageResult(dict):
    def __init__(__self__, *,
                 image_id: builtins.str,
                 image_release_version: builtins.str,
                 keep_image_credential: builtins.bool,
                 security_enhancement_strategy: builtins.str):
        """
        :param builtins.str image_id: 实例的镜像ID。
        :param builtins.str image_release_version: 实例的镜像发布版本。
        :param builtins.bool keep_image_credential: 实例是否保留镜像凭证。
        :param builtins.str security_enhancement_strategy: 实例的安全增强策略。Active：开启安全加固，仅对公共镜像生效。InActive：关闭安全加固，对所有镜像生效。
        """
        pulumi.set(__self__, "image_id", image_id)
        pulumi.set(__self__, "image_release_version", image_release_version)
        pulumi.set(__self__, "keep_image_credential", keep_image_credential)
        pulumi.set(__self__, "security_enhancement_strategy", security_enhancement_strategy)

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> builtins.str:
        """
        实例的镜像ID。
        """
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="imageReleaseVersion")
    def image_release_version(self) -> builtins.str:
        """
        实例的镜像发布版本。
        """
        return pulumi.get(self, "image_release_version")

    @property
    @pulumi.getter(name="keepImageCredential")
    def keep_image_credential(self) -> builtins.bool:
        """
        实例是否保留镜像凭证。
        """
        return pulumi.get(self, "keep_image_credential")

    @property
    @pulumi.getter(name="securityEnhancementStrategy")
    def security_enhancement_strategy(self) -> builtins.str:
        """
        实例的安全增强策略。Active：开启安全加固，仅对公共镜像生效。InActive：关闭安全加固，对所有镜像生效。
        """
        return pulumi.get(self, "security_enhancement_strategy")


@pulumi.output_type
class GetInstanceKeyPairResult(dict):
    def __init__(__self__, *,
                 key_pair_id: builtins.str,
                 key_pair_name: builtins.str):
        """
        :param builtins.str key_pair_id: 实例的公钥。
        :param builtins.str key_pair_name: 实例的密钥对名称。
        """
        pulumi.set(__self__, "key_pair_id", key_pair_id)
        pulumi.set(__self__, "key_pair_name", key_pair_name)

    @property
    @pulumi.getter(name="keyPairId")
    def key_pair_id(self) -> builtins.str:
        """
        实例的公钥。
        """
        return pulumi.get(self, "key_pair_id")

    @property
    @pulumi.getter(name="keyPairName")
    def key_pair_name(self) -> builtins.str:
        """
        实例的密钥对名称。
        """
        return pulumi.get(self, "key_pair_name")


@pulumi.output_type
class GetInstanceOperationSystemResult(dict):
    def __init__(__self__, *,
                 name: builtins.str,
                 type: builtins.str):
        """
        :param builtins.str name: 实例的操作系统名称。
        :param builtins.str type: 实例的操作系统类型。Linux：Linux系统。Windows：Windows系统。
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        实例的操作系统名称。
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def type(self) -> builtins.str:
        """
        实例的操作系统类型。Linux：Linux系统。Windows：Windows系统。
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetInstancePlacementResult(dict):
    def __init__(__self__, *,
                 affinity: builtins.str,
                 dedicated_host_cluster_id: builtins.str,
                 dedicated_host_id: builtins.str,
                 tenancy: builtins.str):
        """
        :param builtins.str affinity: 针对节省停机模式的ECS实例，停止后会释放部分资源，本参数用于查看ECS实例重新启动时是否仍固定部署在原宿主机上。取值：Host：启用节省停机模式的实例重新启动时，仍会部署在原宿主机上。Default（默认）：启用节省停机模式的实例重新启动时，会优先迁移到支持自动部署的宿主机；若支持自动部署的宿主机资源不足，则在原宿主机上进行启动。
        :param builtins.str dedicated_host_cluster_id: 实例的专用主机集群ID。
        :param builtins.str dedicated_host_id: 实例的专用主机ID。
        :param builtins.str tenancy: 是否在专有宿主机上创建实例，取值：Default（默认）：创建普通云服务器实例。Host：创建专有宿主机实例。若您不指定DedicatedHostId，则由系统自动选择专有宿主机放置实例
        """
        pulumi.set(__self__, "affinity", affinity)
        pulumi.set(__self__, "dedicated_host_cluster_id", dedicated_host_cluster_id)
        pulumi.set(__self__, "dedicated_host_id", dedicated_host_id)
        pulumi.set(__self__, "tenancy", tenancy)

    @property
    @pulumi.getter
    def affinity(self) -> builtins.str:
        """
        针对节省停机模式的ECS实例，停止后会释放部分资源，本参数用于查看ECS实例重新启动时是否仍固定部署在原宿主机上。取值：Host：启用节省停机模式的实例重新启动时，仍会部署在原宿主机上。Default（默认）：启用节省停机模式的实例重新启动时，会优先迁移到支持自动部署的宿主机；若支持自动部署的宿主机资源不足，则在原宿主机上进行启动。
        """
        return pulumi.get(self, "affinity")

    @property
    @pulumi.getter(name="dedicatedHostClusterId")
    def dedicated_host_cluster_id(self) -> builtins.str:
        """
        实例的专用主机集群ID。
        """
        return pulumi.get(self, "dedicated_host_cluster_id")

    @property
    @pulumi.getter(name="dedicatedHostId")
    def dedicated_host_id(self) -> builtins.str:
        """
        实例的专用主机ID。
        """
        return pulumi.get(self, "dedicated_host_id")

    @property
    @pulumi.getter
    def tenancy(self) -> builtins.str:
        """
        是否在专有宿主机上创建实例，取值：Default（默认）：创建普通云服务器实例。Host：创建专有宿主机实例。若您不指定DedicatedHostId，则由系统自动选择专有宿主机放置实例
        """
        return pulumi.get(self, "tenancy")


@pulumi.output_type
class GetInstancePrimaryNetworkInterfaceResult(dict):
    def __init__(__self__, *,
                 ipv6_address_count: builtins.int,
                 ipv6_addresses: Sequence[builtins.str],
                 mac_address: builtins.str,
                 network_interface_id: builtins.str,
                 primary_ip_address: builtins.str,
                 private_ip_addresses: Sequence[builtins.str],
                 security_group_ids: Sequence[builtins.str],
                 subnet_id: builtins.str,
                 vpc_id: builtins.str):
        """
        :param builtins.int ipv6_address_count: 实例的IPv6地址数量。
        :param Sequence[builtins.str] ipv6_addresses: 实例的IPv6地址。
        :param builtins.str mac_address: 实例的MAC地址。
        :param builtins.str network_interface_id: 实例的网络接口ID。
        :param builtins.str primary_ip_address: 实例的主IP地址。
        :param Sequence[builtins.str] private_ip_addresses: 实例的私有IP地址。
        :param Sequence[builtins.str] security_group_ids: 实例的安全组ID。
        :param builtins.str subnet_id: 实例的子网ID。
        :param builtins.str vpc_id: 实例的VPC ID。
        """
        pulumi.set(__self__, "ipv6_address_count", ipv6_address_count)
        pulumi.set(__self__, "ipv6_addresses", ipv6_addresses)
        pulumi.set(__self__, "mac_address", mac_address)
        pulumi.set(__self__, "network_interface_id", network_interface_id)
        pulumi.set(__self__, "primary_ip_address", primary_ip_address)
        pulumi.set(__self__, "private_ip_addresses", private_ip_addresses)
        pulumi.set(__self__, "security_group_ids", security_group_ids)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "vpc_id", vpc_id)

    @property
    @pulumi.getter(name="ipv6AddressCount")
    def ipv6_address_count(self) -> builtins.int:
        """
        实例的IPv6地址数量。
        """
        return pulumi.get(self, "ipv6_address_count")

    @property
    @pulumi.getter(name="ipv6Addresses")
    def ipv6_addresses(self) -> Sequence[builtins.str]:
        """
        实例的IPv6地址。
        """
        return pulumi.get(self, "ipv6_addresses")

    @property
    @pulumi.getter(name="macAddress")
    def mac_address(self) -> builtins.str:
        """
        实例的MAC地址。
        """
        return pulumi.get(self, "mac_address")

    @property
    @pulumi.getter(name="networkInterfaceId")
    def network_interface_id(self) -> builtins.str:
        """
        实例的网络接口ID。
        """
        return pulumi.get(self, "network_interface_id")

    @property
    @pulumi.getter(name="primaryIpAddress")
    def primary_ip_address(self) -> builtins.str:
        """
        实例的主IP地址。
        """
        return pulumi.get(self, "primary_ip_address")

    @property
    @pulumi.getter(name="privateIpAddresses")
    def private_ip_addresses(self) -> Sequence[builtins.str]:
        """
        实例的私有IP地址。
        """
        return pulumi.get(self, "private_ip_addresses")

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> Sequence[builtins.str]:
        """
        实例的安全组ID。
        """
        return pulumi.get(self, "security_group_ids")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        """
        实例的子网ID。
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> builtins.str:
        """
        实例的VPC ID。
        """
        return pulumi.get(self, "vpc_id")


@pulumi.output_type
class GetInstanceSecondaryNetworkInterfaceResult(dict):
    def __init__(__self__, *,
                 ipv6_address_count: builtins.int,
                 ipv6_addresses: Sequence[builtins.str],
                 mac_address: builtins.str,
                 network_interface_id: builtins.str,
                 primary_ip_address: builtins.str,
                 private_ip_addresses: Sequence[builtins.str],
                 security_group_ids: Sequence[builtins.str],
                 subnet_id: builtins.str,
                 vpc_id: builtins.str):
        """
        :param builtins.int ipv6_address_count: 实例的IPv6地址数量。
        :param Sequence[builtins.str] ipv6_addresses: 实例的IPv6地址。
        :param builtins.str mac_address: 实例的MAC地址。
        :param builtins.str network_interface_id: 实例的网络接口ID。
        :param builtins.str primary_ip_address: 实例的主IP地址。
        :param Sequence[builtins.str] private_ip_addresses: 实例的私有IP地址。
        :param Sequence[builtins.str] security_group_ids: 实例的安全组ID。
        :param builtins.str subnet_id: 实例的子网ID。
        :param builtins.str vpc_id: 实例的VPC ID。
        """
        pulumi.set(__self__, "ipv6_address_count", ipv6_address_count)
        pulumi.set(__self__, "ipv6_addresses", ipv6_addresses)
        pulumi.set(__self__, "mac_address", mac_address)
        pulumi.set(__self__, "network_interface_id", network_interface_id)
        pulumi.set(__self__, "primary_ip_address", primary_ip_address)
        pulumi.set(__self__, "private_ip_addresses", private_ip_addresses)
        pulumi.set(__self__, "security_group_ids", security_group_ids)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "vpc_id", vpc_id)

    @property
    @pulumi.getter(name="ipv6AddressCount")
    def ipv6_address_count(self) -> builtins.int:
        """
        实例的IPv6地址数量。
        """
        return pulumi.get(self, "ipv6_address_count")

    @property
    @pulumi.getter(name="ipv6Addresses")
    def ipv6_addresses(self) -> Sequence[builtins.str]:
        """
        实例的IPv6地址。
        """
        return pulumi.get(self, "ipv6_addresses")

    @property
    @pulumi.getter(name="macAddress")
    def mac_address(self) -> builtins.str:
        """
        实例的MAC地址。
        """
        return pulumi.get(self, "mac_address")

    @property
    @pulumi.getter(name="networkInterfaceId")
    def network_interface_id(self) -> builtins.str:
        """
        实例的网络接口ID。
        """
        return pulumi.get(self, "network_interface_id")

    @property
    @pulumi.getter(name="primaryIpAddress")
    def primary_ip_address(self) -> builtins.str:
        """
        实例的主IP地址。
        """
        return pulumi.get(self, "primary_ip_address")

    @property
    @pulumi.getter(name="privateIpAddresses")
    def private_ip_addresses(self) -> Sequence[builtins.str]:
        """
        实例的私有IP地址。
        """
        return pulumi.get(self, "private_ip_addresses")

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> Sequence[builtins.str]:
        """
        实例的安全组ID。
        """
        return pulumi.get(self, "security_group_ids")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        """
        实例的子网ID。
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> builtins.str:
        """
        实例的VPC ID。
        """
        return pulumi.get(self, "vpc_id")


@pulumi.output_type
class GetInstanceSystemVolumeResult(dict):
    def __init__(__self__, *,
                 delete_with_instance: builtins.bool,
                 extra_performance_iops: builtins.int,
                 extra_performance_throughput_mb: builtins.int,
                 extra_performance_type_id: builtins.str,
                 size: builtins.int,
                 snapshot_id: builtins.str,
                 volume_id: builtins.str,
                 volume_type: builtins.str):
        """
        :param builtins.bool delete_with_instance: 实例是否随实例删除。
        :param builtins.int extra_performance_iops: 实例的额外性能IOPS。
        :param builtins.int extra_performance_throughput_mb: 实例的额外性能吞吐量，单位MB。
        :param builtins.str extra_performance_type_id: 额外性能的类型，取值如下：Balance：均衡型额外性能。IOPS：IOPS型额外性能。Throughput：吞吐量型额外性能。
        :param builtins.int size: 实例的大小，单位GiB。
        :param builtins.str snapshot_id: 实例的快照ID。
        :param builtins.str volume_id: 实例的卷ID。
        :param builtins.str volume_type: 云盘类型，取值说明如下：PTSSD：性能型SSD。ESSD_PL0：极速型SSD云盘，PL0规格。ESSD_FlexPL: 极速型SSD云盘，FlexPL规格。TSSD_TL0：吞吐型SSD云盘。
        """
        pulumi.set(__self__, "delete_with_instance", delete_with_instance)
        pulumi.set(__self__, "extra_performance_iops", extra_performance_iops)
        pulumi.set(__self__, "extra_performance_throughput_mb", extra_performance_throughput_mb)
        pulumi.set(__self__, "extra_performance_type_id", extra_performance_type_id)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "snapshot_id", snapshot_id)
        pulumi.set(__self__, "volume_id", volume_id)
        pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter(name="deleteWithInstance")
    def delete_with_instance(self) -> builtins.bool:
        """
        实例是否随实例删除。
        """
        return pulumi.get(self, "delete_with_instance")

    @property
    @pulumi.getter(name="extraPerformanceIops")
    def extra_performance_iops(self) -> builtins.int:
        """
        实例的额外性能IOPS。
        """
        return pulumi.get(self, "extra_performance_iops")

    @property
    @pulumi.getter(name="extraPerformanceThroughputMb")
    def extra_performance_throughput_mb(self) -> builtins.int:
        """
        实例的额外性能吞吐量，单位MB。
        """
        return pulumi.get(self, "extra_performance_throughput_mb")

    @property
    @pulumi.getter(name="extraPerformanceTypeId")
    def extra_performance_type_id(self) -> builtins.str:
        """
        额外性能的类型，取值如下：Balance：均衡型额外性能。IOPS：IOPS型额外性能。Throughput：吞吐量型额外性能。
        """
        return pulumi.get(self, "extra_performance_type_id")

    @property
    @pulumi.getter
    def size(self) -> builtins.int:
        """
        实例的大小，单位GiB。
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="snapshotId")
    def snapshot_id(self) -> builtins.str:
        """
        实例的快照ID。
        """
        return pulumi.get(self, "snapshot_id")

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> builtins.str:
        """
        实例的卷ID。
        """
        return pulumi.get(self, "volume_id")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> builtins.str:
        """
        云盘类型，取值说明如下：PTSSD：性能型SSD。ESSD_PL0：极速型SSD云盘，PL0规格。ESSD_FlexPL: 极速型SSD云盘，FlexPL规格。TSSD_TL0：吞吐型SSD云盘。
        """
        return pulumi.get(self, "volume_type")


@pulumi.output_type
class GetInstanceTagResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 value: builtins.str):
        """
        :param builtins.str key: 实例的键。
        :param builtins.str value: 实例的值。
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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


