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

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

__all__ = [
    'ImageDetectionResultsArgs',
    'ImageDetectionResultsArgsDict',
    'ImageDetectionResultsItemArgs',
    'ImageDetectionResultsItemArgsDict',
    'ImageSnapshotArgs',
    'ImageSnapshotArgsDict',
    'ImageTagArgs',
    'ImageTagArgsDict',
    'InstanceCpuMemoryArgs',
    'InstanceCpuMemoryArgsDict',
    'InstanceEipAddressArgs',
    'InstanceEipAddressArgsDict',
    'InstanceImageArgs',
    'InstanceImageArgsDict',
    'InstanceKeyPairArgs',
    'InstanceKeyPairArgsDict',
    'InstanceOperationSystemArgs',
    'InstanceOperationSystemArgsDict',
    'InstancePlacementArgs',
    'InstancePlacementArgsDict',
    'InstancePrimaryNetworkInterfaceArgs',
    'InstancePrimaryNetworkInterfaceArgsDict',
    'InstanceSecondaryNetworkInterfaceArgs',
    'InstanceSecondaryNetworkInterfaceArgsDict',
    'InstanceSystemVolumeArgs',
    'InstanceSystemVolumeArgsDict',
    'InstanceTagArgs',
    'InstanceTagArgsDict',
]

MYPY = False

if not MYPY:
    class ImageDetectionResultsArgsDict(TypedDict):
        detection_status: NotRequired[pulumi.Input[builtins.str]]
        """
        检测状态。可以选择Finished（已完成）、Processing（处理中）类型。
        """
        items: NotRequired[pulumi.Input[Sequence[pulumi.Input['ImageDetectionResultsItemArgsDict']]]]
elif False:
    ImageDetectionResultsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ImageDetectionResultsArgs:
    def __init__(__self__, *,
                 detection_status: Optional[pulumi.Input[builtins.str]] = None,
                 items: Optional[pulumi.Input[Sequence[pulumi.Input['ImageDetectionResultsItemArgs']]]] = None):
        """
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        检测状态。可以选择Finished（已完成）、Processing（处理中）类型。
        """
        return pulumi.get(self, "detection_status")

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

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

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


if not MYPY:
    class ImageDetectionResultsItemArgsDict(TypedDict):
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        检测项名称。
        """
        result: NotRequired[pulumi.Input[builtins.str]]
        """
        该检测项对应结果。
        """
        risk_code: NotRequired[pulumi.Input[builtins.str]]
        """
        风险描述码。
        """
        risk_level: NotRequired[pulumi.Input[builtins.str]]
        """
        风险等级。若该参数返回值为空，表示无风险。
        """
elif False:
    ImageDetectionResultsItemArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ImageDetectionResultsItemArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 result: Optional[pulumi.Input[builtins.str]] = None,
                 risk_code: Optional[pulumi.Input[builtins.str]] = None,
                 risk_level: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] name: 检测项名称。
        :param pulumi.Input[builtins.str] result: 该检测项对应结果。
        :param pulumi.Input[builtins.str] risk_code: 风险描述码。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        检测项名称。
        """
        return pulumi.get(self, "name")

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

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

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

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

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

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

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


if not MYPY:
    class ImageSnapshotArgsDict(TypedDict):
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        快照大小。单位为GiB。
        """
        snapshot_id: NotRequired[pulumi.Input[builtins.str]]
        """
        快照ID。
        """
        volume_kind: NotRequired[pulumi.Input[builtins.str]]
        """
        云盘种类。system：系统盘。data：数据盘。
        """
elif False:
    ImageSnapshotArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ImageSnapshotArgs:
    def __init__(__self__, *,
                 size: Optional[pulumi.Input[builtins.int]] = None,
                 snapshot_id: Optional[pulumi.Input[builtins.str]] = None,
                 volume_kind: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] size: 快照大小。单位为GiB。
        :param pulumi.Input[builtins.str] snapshot_id: 快照ID。
        :param pulumi.Input[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[pulumi.Input[builtins.int]]:
        """
        快照大小。单位为GiB。
        """
        return pulumi.get(self, "size")

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

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

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

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

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


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

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

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

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

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

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


if not MYPY:
    class InstanceCpuMemoryArgsDict(TypedDict):
        core_count: NotRequired[pulumi.Input[builtins.int]]
        """
        实例的核数。
        """
        cpu_number: NotRequired[pulumi.Input[builtins.int]]
        """
        实例的CPU数量。
        """
        memory_size: NotRequired[pulumi.Input[builtins.int]]
        """
        实例的内存大小，单位MB。
        """
        threads_per_core: NotRequired[pulumi.Input[builtins.int]]
        """
        实例的每核线程数。
        """
elif False:
    InstanceCpuMemoryArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceCpuMemoryArgs:
    def __init__(__self__, *,
                 core_count: Optional[pulumi.Input[builtins.int]] = None,
                 cpu_number: Optional[pulumi.Input[builtins.int]] = None,
                 memory_size: Optional[pulumi.Input[builtins.int]] = None,
                 threads_per_core: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.int] core_count: 实例的核数。
        :param pulumi.Input[builtins.int] cpu_number: 实例的CPU数量。
        :param pulumi.Input[builtins.int] memory_size: 实例的内存大小，单位MB。
        :param pulumi.Input[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[pulumi.Input[builtins.int]]:
        """
        实例的核数。
        """
        return pulumi.get(self, "core_count")

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


if not MYPY:
    class InstanceImageArgsDict(TypedDict):
        image_id: pulumi.Input[builtins.str]
        """
        实例的镜像ID。
        """
        image_release_version: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的镜像发布版本。
        """
        keep_image_credential: NotRequired[pulumi.Input[builtins.bool]]
        """
        实例是否保留镜像凭证。
        """
        security_enhancement_strategy: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的安全增强策略。Active：开启安全加固，仅对公共镜像生效。InActive：关闭安全加固，对所有镜像生效。
        """
elif False:
    InstanceImageArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceImageArgs:
    def __init__(__self__, *,
                 image_id: pulumi.Input[builtins.str],
                 image_release_version: Optional[pulumi.Input[builtins.str]] = None,
                 keep_image_credential: Optional[pulumi.Input[builtins.bool]] = None,
                 security_enhancement_strategy: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] image_id: 实例的镜像ID。
        :param pulumi.Input[builtins.str] image_release_version: 实例的镜像发布版本。
        :param pulumi.Input[builtins.bool] keep_image_credential: 实例是否保留镜像凭证。
        :param pulumi.Input[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) -> pulumi.Input[builtins.str]:
        """
        实例的镜像ID。
        """
        return pulumi.get(self, "image_id")

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

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

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

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

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

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

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


if not MYPY:
    class InstanceKeyPairArgsDict(TypedDict):
        key_pair_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的公钥。
        """
        key_pair_name: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的密钥对名称。
        """
elif False:
    InstanceKeyPairArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceKeyPairArgs:
    def __init__(__self__, *,
                 key_pair_id: Optional[pulumi.Input[builtins.str]] = None,
                 key_pair_name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] key_pair_id: 实例的公钥。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        实例的公钥。
        """
        return pulumi.get(self, "key_pair_id")

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

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

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


if not MYPY:
    class InstanceOperationSystemArgsDict(TypedDict):
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的操作系统名称。
        """
        type: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的操作系统类型。Linux：Linux系统。Windows：Windows系统。
        """
elif False:
    InstanceOperationSystemArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceOperationSystemArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] name: 实例的操作系统名称。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        实例的操作系统名称。
        """
        return pulumi.get(self, "name")

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

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

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


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

@pulumi.input_type
class InstancePlacementArgs:
    def __init__(__self__, *,
                 affinity: Optional[pulumi.Input[builtins.str]] = None,
                 dedicated_host_cluster_id: Optional[pulumi.Input[builtins.str]] = None,
                 dedicated_host_id: Optional[pulumi.Input[builtins.str]] = None,
                 tenancy: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] affinity: 针对节省停机模式的ECS实例，停止后会释放部分资源，本参数用于查看ECS实例重新启动时是否仍固定部署在原宿主机上。取值：Host：启用节省停机模式的实例重新启动时，仍会部署在原宿主机上。Default（默认）：启用节省停机模式的实例重新启动时，会优先迁移到支持自动部署的宿主机；若支持自动部署的宿主机资源不足，则在原宿主机上进行启动。
        :param pulumi.Input[builtins.str] dedicated_host_cluster_id: 实例的专用主机集群ID。
        :param pulumi.Input[builtins.str] dedicated_host_id: 实例的专用主机ID。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        针对节省停机模式的ECS实例，停止后会释放部分资源，本参数用于查看ECS实例重新启动时是否仍固定部署在原宿主机上。取值：Host：启用节省停机模式的实例重新启动时，仍会部署在原宿主机上。Default（默认）：启用节省停机模式的实例重新启动时，会优先迁移到支持自动部署的宿主机；若支持自动部署的宿主机资源不足，则在原宿主机上进行启动。
        """
        return pulumi.get(self, "affinity")

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

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

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

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

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

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

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


if not MYPY:
    class InstancePrimaryNetworkInterfaceArgsDict(TypedDict):
        security_group_ids: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
        """
        实例的安全组ID。
        """
        subnet_id: pulumi.Input[builtins.str]
        """
        实例的子网ID。
        """
        ipv6_address_count: NotRequired[pulumi.Input[builtins.int]]
        """
        实例的IPv6地址数量。
        """
        ipv6_addresses: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        实例的IPv6地址。
        """
        mac_address: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的MAC地址。
        """
        network_interface_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的网络接口ID。
        """
        primary_ip_address: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的主IP地址。
        """
        private_ip_addresses: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        实例的私有IP地址。
        """
        vpc_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的VPC ID。
        """
elif False:
    InstancePrimaryNetworkInterfaceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstancePrimaryNetworkInterfaceArgs:
    def __init__(__self__, *,
                 security_group_ids: pulumi.Input[Sequence[pulumi.Input[builtins.str]]],
                 subnet_id: pulumi.Input[builtins.str],
                 ipv6_address_count: Optional[pulumi.Input[builtins.int]] = None,
                 ipv6_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 mac_address: Optional[pulumi.Input[builtins.str]] = None,
                 network_interface_id: Optional[pulumi.Input[builtins.str]] = None,
                 primary_ip_address: Optional[pulumi.Input[builtins.str]] = None,
                 private_ip_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 vpc_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_group_ids: 实例的安全组ID。
        :param pulumi.Input[builtins.str] subnet_id: 实例的子网ID。
        :param pulumi.Input[builtins.int] ipv6_address_count: 实例的IPv6地址数量。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv6_addresses: 实例的IPv6地址。
        :param pulumi.Input[builtins.str] mac_address: 实例的MAC地址。
        :param pulumi.Input[builtins.str] network_interface_id: 实例的网络接口ID。
        :param pulumi.Input[builtins.str] primary_ip_address: 实例的主IP地址。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] private_ip_addresses: 实例的私有IP地址。
        :param pulumi.Input[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) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
        """
        实例的安全组ID。
        """
        return pulumi.get(self, "security_group_ids")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


if not MYPY:
    class InstanceSecondaryNetworkInterfaceArgsDict(TypedDict):
        ipv6_address_count: NotRequired[pulumi.Input[builtins.int]]
        """
        实例的IPv6地址数量。
        """
        primary_ip_address: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的主IP地址。
        """
        private_ip_addresses: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        实例的私有IP地址。
        """
        security_group_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        实例的安全组ID。
        """
        subnet_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的子网ID。
        """
        vpc_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的VPC ID。
        """
elif False:
    InstanceSecondaryNetworkInterfaceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceSecondaryNetworkInterfaceArgs:
    def __init__(__self__, *,
                 ipv6_address_count: Optional[pulumi.Input[builtins.int]] = None,
                 primary_ip_address: Optional[pulumi.Input[builtins.str]] = None,
                 private_ip_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 subnet_id: Optional[pulumi.Input[builtins.str]] = None,
                 vpc_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] ipv6_address_count: 实例的IPv6地址数量。
        :param pulumi.Input[builtins.str] primary_ip_address: 实例的主IP地址。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] private_ip_addresses: 实例的私有IP地址。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_group_ids: 实例的安全组ID。
        :param pulumi.Input[builtins.str] subnet_id: 实例的子网ID。
        :param pulumi.Input[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[pulumi.Input[builtins.int]]:
        """
        实例的IPv6地址数量。
        """
        return pulumi.get(self, "ipv6_address_count")

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

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

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

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

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

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

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

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

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

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

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


if not MYPY:
    class InstanceSystemVolumeArgsDict(TypedDict):
        delete_with_instance: NotRequired[pulumi.Input[builtins.bool]]
        """
        实例是否随实例删除。
        """
        extra_performance_iops: NotRequired[pulumi.Input[builtins.int]]
        """
        实例的额外性能IOPS。
        """
        extra_performance_throughput_mb: NotRequired[pulumi.Input[builtins.int]]
        """
        实例的额外性能吞吐量，单位MB。
        """
        extra_performance_type_id: NotRequired[pulumi.Input[builtins.str]]
        """
        额外性能的类型，取值如下：Balance：均衡型额外性能。IOPS：IOPS型额外性能。Throughput：吞吐量型额外性能。
        """
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        实例的大小，单位GiB。
        """
        snapshot_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的快照ID。
        """
        volume_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的卷ID。
        """
        volume_type: NotRequired[pulumi.Input[builtins.str]]
        """
        云盘类型，取值说明如下：PTSSD：性能型SSD。ESSD_PL0：极速型SSD云盘，PL0规格。ESSD_FlexPL: 极速型SSD云盘，FlexPL规格。TSSD_TL0：吞吐型SSD云盘。
        """
elif False:
    InstanceSystemVolumeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceSystemVolumeArgs:
    def __init__(__self__, *,
                 delete_with_instance: Optional[pulumi.Input[builtins.bool]] = None,
                 extra_performance_iops: Optional[pulumi.Input[builtins.int]] = None,
                 extra_performance_throughput_mb: Optional[pulumi.Input[builtins.int]] = None,
                 extra_performance_type_id: Optional[pulumi.Input[builtins.str]] = None,
                 size: Optional[pulumi.Input[builtins.int]] = None,
                 snapshot_id: Optional[pulumi.Input[builtins.str]] = None,
                 volume_id: Optional[pulumi.Input[builtins.str]] = None,
                 volume_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.bool] delete_with_instance: 实例是否随实例删除。
        :param pulumi.Input[builtins.int] extra_performance_iops: 实例的额外性能IOPS。
        :param pulumi.Input[builtins.int] extra_performance_throughput_mb: 实例的额外性能吞吐量，单位MB。
        :param pulumi.Input[builtins.str] extra_performance_type_id: 额外性能的类型，取值如下：Balance：均衡型额外性能。IOPS：IOPS型额外性能。Throughput：吞吐量型额外性能。
        :param pulumi.Input[builtins.int] size: 实例的大小，单位GiB。
        :param pulumi.Input[builtins.str] snapshot_id: 实例的快照ID。
        :param pulumi.Input[builtins.str] volume_id: 实例的卷ID。
        :param pulumi.Input[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[pulumi.Input[builtins.bool]]:
        """
        实例是否随实例删除。
        """
        return pulumi.get(self, "delete_with_instance")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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


