# 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__ = [
    'CommandParameterDefinitionArgs',
    'CommandParameterDefinitionArgsDict',
    'CommandTagArgs',
    'CommandTagArgsDict',
    'DeploymentSetCapacityArgs',
    'DeploymentSetCapacityArgsDict',
    'ImageDetectionResultsArgs',
    'ImageDetectionResultsArgsDict',
    'ImageDetectionResultsItemArgs',
    'ImageDetectionResultsItemArgsDict',
    'ImageSnapshotArgs',
    'ImageSnapshotArgsDict',
    'ImageTagArgs',
    'ImageTagArgsDict',
    'InstanceCpuMemoryArgs',
    'InstanceCpuMemoryArgsDict',
    'InstanceEipAddressArgs',
    'InstanceEipAddressArgsDict',
    'InstanceImageArgs',
    'InstanceImageArgsDict',
    'InstanceKeyPairArgs',
    'InstanceKeyPairArgsDict',
    'InstanceLocalVolumeArgs',
    'InstanceLocalVolumeArgsDict',
    'InstanceOperationSystemArgs',
    'InstanceOperationSystemArgsDict',
    'InstancePlacementArgs',
    'InstancePlacementArgsDict',
    'InstancePrimaryNetworkInterfaceArgs',
    'InstancePrimaryNetworkInterfaceArgsDict',
    'InstanceRdmaNetworkInterfaceDetailArgs',
    'InstanceRdmaNetworkInterfaceDetailArgsDict',
    'InstanceRenewInfoArgs',
    'InstanceRenewInfoArgsDict',
    'InstanceSecondaryNetworkInterfaceArgs',
    'InstanceSecondaryNetworkInterfaceArgsDict',
    'InstanceSystemVolumeArgs',
    'InstanceSystemVolumeArgsDict',
    'InstanceTagArgs',
    'InstanceTagArgsDict',
    'InvocationInvocationResultArgs',
    'InvocationInvocationResultArgsDict',
    'InvocationParameterDefinitionArgs',
    'InvocationParameterDefinitionArgsDict',
    'InvocationTagArgs',
    'InvocationTagArgsDict',
    'KeypairTagArgs',
    'KeypairTagArgsDict',
    'LaunchTemplateLaunchTemplateTagArgs',
    'LaunchTemplateLaunchTemplateTagArgsDict',
    'LaunchTemplateLaunchTemplateVersionArgs',
    'LaunchTemplateLaunchTemplateVersionArgsDict',
    'LaunchTemplateLaunchTemplateVersionEipArgs',
    'LaunchTemplateLaunchTemplateVersionEipArgsDict',
    'LaunchTemplateLaunchTemplateVersionNetworkInterfaceArgs',
    'LaunchTemplateLaunchTemplateVersionNetworkInterfaceArgsDict',
    'LaunchTemplateLaunchTemplateVersionScheduledInstanceArgs',
    'LaunchTemplateLaunchTemplateVersionScheduledInstanceArgsDict',
    'LaunchTemplateLaunchTemplateVersionTagArgs',
    'LaunchTemplateLaunchTemplateVersionTagArgsDict',
    'LaunchTemplateLaunchTemplateVersionVolumeArgs',
    'LaunchTemplateLaunchTemplateVersionVolumeArgsDict',
    'LaunchTemplateVersionEipArgs',
    'LaunchTemplateVersionEipArgsDict',
    'LaunchTemplateVersionNetworkInterfaceArgs',
    'LaunchTemplateVersionNetworkInterfaceArgsDict',
    'LaunchTemplateVersionScheduledInstanceArgs',
    'LaunchTemplateVersionScheduledInstanceArgsDict',
    'LaunchTemplateVersionTagArgs',
    'LaunchTemplateVersionTagArgsDict',
    'LaunchTemplateVersionVolumeArgs',
    'LaunchTemplateVersionVolumeArgsDict',
]

MYPY = False

if not MYPY:
    class CommandParameterDefinitionArgsDict(TypedDict):
        decimal_precision: NotRequired[pulumi.Input[builtins.int]]
        """
        自定义参数值（数字）允许的小数点后位数。
        """
        default_value: NotRequired[pulumi.Input[builtins.str]]
        """
        自定义参数默认值。
        """
        max_length: NotRequired[pulumi.Input[builtins.int]]
        """
        自定义参数值（字符串）的最大长度。
        """
        max_value: NotRequired[pulumi.Input[builtins.str]]
        """
        自定义参数值（数字）的最大值。
        """
        min_length: NotRequired[pulumi.Input[builtins.int]]
        """
        自定义参数值（字符串）的最小长度。
        """
        min_value: NotRequired[pulumi.Input[builtins.str]]
        """
        自定义参数值（数字）的最小值。
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        自定义参数名称，需要在脚本中通过{{Param}}定义 。单个参数名不能超过64字节。遵循Shell变量命名规则，a-zA-Z0-9-_的组合。首个字符不能以数字开头。中间不能有空格，可以使用下划线。
        """
        required: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否必填。
        """
        type: NotRequired[pulumi.Input[builtins.str]]
        """
        自定义参数类型。取值：String：表示自定义参数类型为String（字符串）类型。Digit：表示自定义参数类型为Digit（数值）类型。
        """
elif False:
    CommandParameterDefinitionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CommandParameterDefinitionArgs:
    def __init__(__self__, *,
                 decimal_precision: Optional[pulumi.Input[builtins.int]] = None,
                 default_value: Optional[pulumi.Input[builtins.str]] = None,
                 max_length: Optional[pulumi.Input[builtins.int]] = None,
                 max_value: Optional[pulumi.Input[builtins.str]] = None,
                 min_length: Optional[pulumi.Input[builtins.int]] = None,
                 min_value: Optional[pulumi.Input[builtins.str]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 required: Optional[pulumi.Input[builtins.bool]] = None,
                 type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] decimal_precision: 自定义参数值（数字）允许的小数点后位数。
        :param pulumi.Input[builtins.str] default_value: 自定义参数默认值。
        :param pulumi.Input[builtins.int] max_length: 自定义参数值（字符串）的最大长度。
        :param pulumi.Input[builtins.str] max_value: 自定义参数值（数字）的最大值。
        :param pulumi.Input[builtins.int] min_length: 自定义参数值（字符串）的最小长度。
        :param pulumi.Input[builtins.str] min_value: 自定义参数值（数字）的最小值。
        :param pulumi.Input[builtins.str] name: 自定义参数名称，需要在脚本中通过{{Param}}定义 。单个参数名不能超过64字节。遵循Shell变量命名规则，a-zA-Z0-9-_的组合。首个字符不能以数字开头。中间不能有空格，可以使用下划线。
        :param pulumi.Input[builtins.bool] required: 是否必填。
        :param pulumi.Input[builtins.str] type: 自定义参数类型。取值：String：表示自定义参数类型为String（字符串）类型。Digit：表示自定义参数类型为Digit（数值）类型。
        """
        if decimal_precision is not None:
            pulumi.set(__self__, "decimal_precision", decimal_precision)
        if default_value is not None:
            pulumi.set(__self__, "default_value", default_value)
        if max_length is not None:
            pulumi.set(__self__, "max_length", max_length)
        if max_value is not None:
            pulumi.set(__self__, "max_value", max_value)
        if min_length is not None:
            pulumi.set(__self__, "min_length", min_length)
        if min_value is not None:
            pulumi.set(__self__, "min_value", min_value)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if required is not None:
            pulumi.set(__self__, "required", required)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="decimalPrecision")
    def decimal_precision(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        自定义参数值（数字）允许的小数点后位数。
        """
        return pulumi.get(self, "decimal_precision")

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

    @property
    @pulumi.getter(name="defaultValue")
    def default_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        自定义参数默认值。
        """
        return pulumi.get(self, "default_value")

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

    @property
    @pulumi.getter(name="maxLength")
    def max_length(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        自定义参数值（字符串）的最大长度。
        """
        return pulumi.get(self, "max_length")

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

    @property
    @pulumi.getter(name="maxValue")
    def max_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        自定义参数值（数字）的最大值。
        """
        return pulumi.get(self, "max_value")

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

    @property
    @pulumi.getter(name="minLength")
    def min_length(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        自定义参数值（字符串）的最小长度。
        """
        return pulumi.get(self, "min_length")

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

    @property
    @pulumi.getter(name="minValue")
    def min_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        自定义参数值（数字）的最小值。
        """
        return pulumi.get(self, "min_value")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        自定义参数名称，需要在脚本中通过{{Param}}定义 。单个参数名不能超过64字节。遵循Shell变量命名规则，a-zA-Z0-9-_的组合。首个字符不能以数字开头。中间不能有空格，可以使用下划线。
        """
        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 required(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否必填。
        """
        return pulumi.get(self, "required")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        自定义参数类型。取值：String：表示自定义参数类型为String（字符串）类型。Digit：表示自定义参数类型为Digit（数值）类型。
        """
        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 CommandTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        用户标签的标签键。命名规则如下：不能以volc:或sys:的任意大小写组合开头。只能包含语言字符、数字、空格和英文符号“_”、“.”、“:”、“/”、“=”、“+”、“-”、“@”。长度限制在1～128个字符之间。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        用户标签的标签值。命名规则如下：只能包含语言字符、数字、空格和英文符号“_”、“.”、“:”、“/”、“=”、“+”、“-”、“@”。允许为空，长度限制在0～256个字符之间。
        """
elif False:
    CommandTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CommandTagArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] key: 用户标签的标签键。命名规则如下：不能以volc:或sys:的任意大小写组合开头。只能包含语言字符、数字、空格和英文符号“_”、“.”、“:”、“/”、“=”、“+”、“-”、“@”。长度限制在1～128个字符之间。
        :param pulumi.Input[builtins.str] value: 用户标签的标签值。命名规则如下：只能包含语言字符、数字、空格和英文符号“_”、“.”、“:”、“/”、“=”、“+”、“-”、“@”。允许为空，长度限制在0～256个字符之间。
        """
        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]]:
        """
        用户标签的标签键。命名规则如下：不能以volc:或sys:的任意大小写组合开头。只能包含语言字符、数字、空格和英文符号“_”、“.”、“:”、“/”、“=”、“+”、“-”、“@”。长度限制在1～128个字符之间。
        """
        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]]:
        """
        用户标签的标签值。命名规则如下：只能包含语言字符、数字、空格和英文符号“_”、“.”、“:”、“/”、“=”、“+”、“-”、“@”。允许为空，长度限制在0～256个字符之间。
        """
        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 DeploymentSetCapacityArgsDict(TypedDict):
        available_count: NotRequired[pulumi.Input[builtins.int]]
        """
        该可用区内，还可以加入当前部署集的ECS实例数量。
        """
        used_count: NotRequired[pulumi.Input[builtins.int]]
        """
        部署集内属于该可用区的ECS实例数量。
        """
        zone_id: NotRequired[pulumi.Input[builtins.str]]
        """
        可用区ID。只返回部署集内存量ECS实例所属的可用区ID。
        """
elif False:
    DeploymentSetCapacityArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DeploymentSetCapacityArgs:
    def __init__(__self__, *,
                 available_count: Optional[pulumi.Input[builtins.int]] = None,
                 used_count: Optional[pulumi.Input[builtins.int]] = None,
                 zone_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] available_count: 该可用区内，还可以加入当前部署集的ECS实例数量。
        :param pulumi.Input[builtins.int] used_count: 部署集内属于该可用区的ECS实例数量。
        :param pulumi.Input[builtins.str] zone_id: 可用区ID。只返回部署集内存量ECS实例所属的可用区ID。
        """
        if available_count is not None:
            pulumi.set(__self__, "available_count", available_count)
        if used_count is not None:
            pulumi.set(__self__, "used_count", used_count)
        if zone_id is not None:
            pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter(name="availableCount")
    def available_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        该可用区内，还可以加入当前部署集的ECS实例数量。
        """
        return pulumi.get(self, "available_count")

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

    @property
    @pulumi.getter(name="usedCount")
    def used_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        部署集内属于该可用区的ECS实例数量。
        """
        return pulumi.get(self, "used_count")

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

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        可用区ID。只返回部署集内存量ECS实例所属的可用区ID。
        """
        return pulumi.get(self, "zone_id")

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


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：包年包月。
          
          **提示:**
          实例的计费类型`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]]
        """
        实例是否随实例释放。
        """
        security_protection_instance_id: NotRequired[pulumi.Input[builtins.int]]
        """
        DDoS原生防护（企业版）ID。
        """
        security_protection_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        公网IP的安全防护类型。
        """
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,
                 security_protection_instance_id: Optional[pulumi.Input[builtins.int]] = None,
                 security_protection_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = 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：包年包月。
                 
                 **提示:**
                 实例的计费类型`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: 实例是否随实例释放。
        :param pulumi.Input[builtins.int] security_protection_instance_id: DDoS原生防护（企业版）ID。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_protection_types: 公网IP的安全防护类型。
        """
        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)
        if security_protection_instance_id is not None:
            pulumi.set(__self__, "security_protection_instance_id", security_protection_instance_id)
        if security_protection_types is not None:
            pulumi.set(__self__, "security_protection_types", security_protection_types)

    @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：包年包月。
          
          **提示:**
          实例的计费类型`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)

    @property
    @pulumi.getter(name="securityProtectionInstanceId")
    def security_protection_instance_id(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        DDoS原生防护（企业版）ID。
        """
        return pulumi.get(self, "security_protection_instance_id")

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

    @property
    @pulumi.getter(name="securityProtectionTypes")
    def security_protection_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        公网IP的安全防护类型。
        """
        return pulumi.get(self, "security_protection_types")

    @security_protection_types.setter
    def security_protection_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "security_protection_types", 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 InstanceLocalVolumeArgsDict(TypedDict):
        count: NotRequired[pulumi.Input[builtins.int]]
        """
        实例挂载的本地盘数量。
        """
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        实例挂载的本地盘的单盘容量，单位GiB。
        """
        volume_type: NotRequired[pulumi.Input[builtins.str]]
        """
        本地盘类型，取值：LOCAL_SSD：SSD本地盘。LOCAL_HDD：HDD本地盘。
        """
elif False:
    InstanceLocalVolumeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceLocalVolumeArgs:
    def __init__(__self__, *,
                 count: Optional[pulumi.Input[builtins.int]] = None,
                 size: Optional[pulumi.Input[builtins.int]] = None,
                 volume_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] count: 实例挂载的本地盘数量。
        :param pulumi.Input[builtins.int] size: 实例挂载的本地盘的单盘容量，单位GiB。
        :param pulumi.Input[builtins.str] volume_type: 本地盘类型，取值：LOCAL_SSD：SSD本地盘。LOCAL_HDD：HDD本地盘。
        """
        if count is not None:
            pulumi.set(__self__, "count", count)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter
    def count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        实例挂载的本地盘数量。
        """
        return pulumi.get(self, "count")

    @count.setter
    def count(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "count", 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="volumeType")
    def volume_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        本地盘类型，取值：LOCAL_SSD：SSD本地盘。LOCAL_HDD：HDD本地盘。
        """
        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 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):
        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地址。
        """
        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:
    InstancePrimaryNetworkInterfaceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstancePrimaryNetworkInterfaceArgs:
    def __init__(__self__, *,
                 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,
                 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[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[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 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 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="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="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 InstanceRdmaNetworkInterfaceDetailArgsDict(TypedDict):
        gateway: NotRequired[pulumi.Input[builtins.str]]
        """
        网关地址。
        """
        ip: NotRequired[pulumi.Input[builtins.str]]
        """
        IP地址。
        """
        mask: NotRequired[pulumi.Input[builtins.str]]
        """
        子网掩码。
        """
        switch_name: NotRequired[pulumi.Input[builtins.str]]
        """
        交换机名称。
        """
        switch_port: NotRequired[pulumi.Input[builtins.str]]
        """
        交换机端口。
        """
elif False:
    InstanceRdmaNetworkInterfaceDetailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceRdmaNetworkInterfaceDetailArgs:
    def __init__(__self__, *,
                 gateway: Optional[pulumi.Input[builtins.str]] = None,
                 ip: Optional[pulumi.Input[builtins.str]] = None,
                 mask: Optional[pulumi.Input[builtins.str]] = None,
                 switch_name: Optional[pulumi.Input[builtins.str]] = None,
                 switch_port: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] gateway: 网关地址。
        :param pulumi.Input[builtins.str] ip: IP地址。
        :param pulumi.Input[builtins.str] mask: 子网掩码。
        :param pulumi.Input[builtins.str] switch_name: 交换机名称。
        :param pulumi.Input[builtins.str] switch_port: 交换机端口。
        """
        if gateway is not None:
            pulumi.set(__self__, "gateway", gateway)
        if ip is not None:
            pulumi.set(__self__, "ip", ip)
        if mask is not None:
            pulumi.set(__self__, "mask", mask)
        if switch_name is not None:
            pulumi.set(__self__, "switch_name", switch_name)
        if switch_port is not None:
            pulumi.set(__self__, "switch_port", switch_port)

    @property
    @pulumi.getter
    def gateway(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        网关地址。
        """
        return pulumi.get(self, "gateway")

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

    @property
    @pulumi.getter
    def ip(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        IP地址。
        """
        return pulumi.get(self, "ip")

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

    @property
    @pulumi.getter
    def mask(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        子网掩码。
        """
        return pulumi.get(self, "mask")

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

    @property
    @pulumi.getter(name="switchName")
    def switch_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        交换机名称。
        """
        return pulumi.get(self, "switch_name")

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

    @property
    @pulumi.getter(name="switchPort")
    def switch_port(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        交换机端口。
        """
        return pulumi.get(self, "switch_port")

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


if not MYPY:
    class InstanceRenewInfoArgsDict(TypedDict):
        period: NotRequired[pulumi.Input[builtins.int]]
        """
        续费的月数，取值：1、2、3、4、5、6、7、8、9、12、24、36。
        """
        period_unit: NotRequired[pulumi.Input[builtins.str]]
        """
        续费时长的时间单位，即参数Period的单位。取值：Month（默认）。
        """
elif False:
    InstanceRenewInfoArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceRenewInfoArgs:
    def __init__(__self__, *,
                 period: Optional[pulumi.Input[builtins.int]] = None,
                 period_unit: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] period: 续费的月数，取值：1、2、3、4、5、6、7、8、9、12、24、36。
        :param pulumi.Input[builtins.str] period_unit: 续费时长的时间单位，即参数Period的单位。取值：Month（默认）。
        """
        if period is not None:
            pulumi.set(__self__, "period", period)
        if period_unit is not None:
            pulumi.set(__self__, "period_unit", period_unit)

    @property
    @pulumi.getter
    def period(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        续费的月数，取值：1、2、3、4、5、6、7、8、9、12、24、36。
        """
        return pulumi.get(self, "period")

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

    @property
    @pulumi.getter(name="periodUnit")
    def period_unit(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        续费时长的时间单位，即参数Period的单位。取值：Month（默认）。
        """
        return pulumi.get(self, "period_unit")

    @period_unit.setter
    def period_unit(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "period_unit", 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。
        """
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):
        """
        :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。
        """
        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)

    @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)


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)


if not MYPY:
    class InvocationInvocationResultArgsDict(TypedDict):
        command_id: NotRequired[pulumi.Input[builtins.str]]
        """
        命令ID。
        """
        end_time: NotRequired[pulumi.Input[builtins.str]]
        """
        命令执行的完成时间。
        """
        error_code: NotRequired[pulumi.Input[builtins.str]]
        """
        命令执行失败的错误码。TaskDeliveryTimeout：表示命令下发超时。TaskExecutionTimeout：表示命令执行超时。TaskExecutionFailed：表示命令执行失败。
        """
        error_message: NotRequired[pulumi.Input[builtins.str]]
        """
        命令执行失败的错误信息。
        """
        exit_code: NotRequired[pulumi.Input[builtins.int]]
        """
        脚本执行后的退出状态码。
        """
        instance_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例ID。
        """
        invocation_id: NotRequired[pulumi.Input[builtins.str]]
        """
        任务执行ID。
        """
        invocation_result_id: NotRequired[pulumi.Input[builtins.str]]
        """
        任务执行结果ID。
        """
        invocation_result_status: NotRequired[pulumi.Input[builtins.str]]
        """
        单台实例的命令进度状态。
        """
        output: NotRequired[pulumi.Input[builtins.str]]
        """
        经过Base64编码的命令执行后输出信息。
        """
        start_time: NotRequired[pulumi.Input[builtins.str]]
        """
        命令在实例中开始执行的时间。
        """
        username: NotRequired[pulumi.Input[builtins.str]]
        """
        在实例中执行命令的用户名称。
        """
elif False:
    InvocationInvocationResultArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InvocationInvocationResultArgs:
    def __init__(__self__, *,
                 command_id: Optional[pulumi.Input[builtins.str]] = None,
                 end_time: Optional[pulumi.Input[builtins.str]] = None,
                 error_code: Optional[pulumi.Input[builtins.str]] = None,
                 error_message: Optional[pulumi.Input[builtins.str]] = None,
                 exit_code: Optional[pulumi.Input[builtins.int]] = None,
                 instance_id: Optional[pulumi.Input[builtins.str]] = None,
                 invocation_id: Optional[pulumi.Input[builtins.str]] = None,
                 invocation_result_id: Optional[pulumi.Input[builtins.str]] = None,
                 invocation_result_status: Optional[pulumi.Input[builtins.str]] = None,
                 output: Optional[pulumi.Input[builtins.str]] = None,
                 start_time: Optional[pulumi.Input[builtins.str]] = None,
                 username: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] command_id: 命令ID。
        :param pulumi.Input[builtins.str] end_time: 命令执行的完成时间。
        :param pulumi.Input[builtins.str] error_code: 命令执行失败的错误码。TaskDeliveryTimeout：表示命令下发超时。TaskExecutionTimeout：表示命令执行超时。TaskExecutionFailed：表示命令执行失败。
        :param pulumi.Input[builtins.str] error_message: 命令执行失败的错误信息。
        :param pulumi.Input[builtins.int] exit_code: 脚本执行后的退出状态码。
        :param pulumi.Input[builtins.str] instance_id: 实例ID。
        :param pulumi.Input[builtins.str] invocation_id: 任务执行ID。
        :param pulumi.Input[builtins.str] invocation_result_id: 任务执行结果ID。
        :param pulumi.Input[builtins.str] invocation_result_status: 单台实例的命令进度状态。
        :param pulumi.Input[builtins.str] output: 经过Base64编码的命令执行后输出信息。
        :param pulumi.Input[builtins.str] start_time: 命令在实例中开始执行的时间。
        :param pulumi.Input[builtins.str] username: 在实例中执行命令的用户名称。
        """
        if command_id is not None:
            pulumi.set(__self__, "command_id", command_id)
        if end_time is not None:
            pulumi.set(__self__, "end_time", end_time)
        if error_code is not None:
            pulumi.set(__self__, "error_code", error_code)
        if error_message is not None:
            pulumi.set(__self__, "error_message", error_message)
        if exit_code is not None:
            pulumi.set(__self__, "exit_code", exit_code)
        if instance_id is not None:
            pulumi.set(__self__, "instance_id", instance_id)
        if invocation_id is not None:
            pulumi.set(__self__, "invocation_id", invocation_id)
        if invocation_result_id is not None:
            pulumi.set(__self__, "invocation_result_id", invocation_result_id)
        if invocation_result_status is not None:
            pulumi.set(__self__, "invocation_result_status", invocation_result_status)
        if output is not None:
            pulumi.set(__self__, "output", output)
        if start_time is not None:
            pulumi.set(__self__, "start_time", start_time)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="commandId")
    def command_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        命令ID。
        """
        return pulumi.get(self, "command_id")

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

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        命令执行的完成时间。
        """
        return pulumi.get(self, "end_time")

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

    @property
    @pulumi.getter(name="errorCode")
    def error_code(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        命令执行失败的错误码。TaskDeliveryTimeout：表示命令下发超时。TaskExecutionTimeout：表示命令执行超时。TaskExecutionFailed：表示命令执行失败。
        """
        return pulumi.get(self, "error_code")

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

    @property
    @pulumi.getter(name="errorMessage")
    def error_message(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        命令执行失败的错误信息。
        """
        return pulumi.get(self, "error_message")

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

    @property
    @pulumi.getter(name="exitCode")
    def exit_code(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        脚本执行后的退出状态码。
        """
        return pulumi.get(self, "exit_code")

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

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

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

    @property
    @pulumi.getter(name="invocationId")
    def invocation_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        任务执行ID。
        """
        return pulumi.get(self, "invocation_id")

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

    @property
    @pulumi.getter(name="invocationResultId")
    def invocation_result_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        任务执行结果ID。
        """
        return pulumi.get(self, "invocation_result_id")

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

    @property
    @pulumi.getter(name="invocationResultStatus")
    def invocation_result_status(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        单台实例的命令进度状态。
        """
        return pulumi.get(self, "invocation_result_status")

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

    @property
    @pulumi.getter
    def output(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        经过Base64编码的命令执行后输出信息。
        """
        return pulumi.get(self, "output")

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

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        命令在实例中开始执行的时间。
        """
        return pulumi.get(self, "start_time")

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

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        在实例中执行命令的用户名称。
        """
        return pulumi.get(self, "username")

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


if not MYPY:
    class InvocationParameterDefinitionArgsDict(TypedDict):
        decimal_precision: NotRequired[pulumi.Input[builtins.int]]
        """
        自定义参数值（数字）允许的小数点后位数。
        """
        default_value: NotRequired[pulumi.Input[builtins.str]]
        """
        自定义参数默认值。
        """
        max_length: NotRequired[pulumi.Input[builtins.int]]
        """
        自定义参数值（字符串）的最大长度。
        """
        max_value: NotRequired[pulumi.Input[builtins.str]]
        """
        自定义参数值（数字）的最大值。
        """
        min_length: NotRequired[pulumi.Input[builtins.int]]
        """
        自定义参数值（字符串）的最小长度。
        """
        min_value: NotRequired[pulumi.Input[builtins.str]]
        """
        自定义参数值（数字）的最小值。
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        自定义参数名称，需要在脚本中通过{{Param}}定义 。
        """
        required: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否必填。true：必填。false：非必填。
        """
        type: NotRequired[pulumi.Input[builtins.str]]
        """
        自定义参数类型。String：表示自定义参数类型字符串类型。Digit：表示自定义参数类型为数值类型。
        """
elif False:
    InvocationParameterDefinitionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InvocationParameterDefinitionArgs:
    def __init__(__self__, *,
                 decimal_precision: Optional[pulumi.Input[builtins.int]] = None,
                 default_value: Optional[pulumi.Input[builtins.str]] = None,
                 max_length: Optional[pulumi.Input[builtins.int]] = None,
                 max_value: Optional[pulumi.Input[builtins.str]] = None,
                 min_length: Optional[pulumi.Input[builtins.int]] = None,
                 min_value: Optional[pulumi.Input[builtins.str]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 required: Optional[pulumi.Input[builtins.bool]] = None,
                 type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] decimal_precision: 自定义参数值（数字）允许的小数点后位数。
        :param pulumi.Input[builtins.str] default_value: 自定义参数默认值。
        :param pulumi.Input[builtins.int] max_length: 自定义参数值（字符串）的最大长度。
        :param pulumi.Input[builtins.str] max_value: 自定义参数值（数字）的最大值。
        :param pulumi.Input[builtins.int] min_length: 自定义参数值（字符串）的最小长度。
        :param pulumi.Input[builtins.str] min_value: 自定义参数值（数字）的最小值。
        :param pulumi.Input[builtins.str] name: 自定义参数名称，需要在脚本中通过{{Param}}定义 。
        :param pulumi.Input[builtins.bool] required: 是否必填。true：必填。false：非必填。
        :param pulumi.Input[builtins.str] type: 自定义参数类型。String：表示自定义参数类型字符串类型。Digit：表示自定义参数类型为数值类型。
        """
        if decimal_precision is not None:
            pulumi.set(__self__, "decimal_precision", decimal_precision)
        if default_value is not None:
            pulumi.set(__self__, "default_value", default_value)
        if max_length is not None:
            pulumi.set(__self__, "max_length", max_length)
        if max_value is not None:
            pulumi.set(__self__, "max_value", max_value)
        if min_length is not None:
            pulumi.set(__self__, "min_length", min_length)
        if min_value is not None:
            pulumi.set(__self__, "min_value", min_value)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if required is not None:
            pulumi.set(__self__, "required", required)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="decimalPrecision")
    def decimal_precision(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        自定义参数值（数字）允许的小数点后位数。
        """
        return pulumi.get(self, "decimal_precision")

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

    @property
    @pulumi.getter(name="defaultValue")
    def default_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        自定义参数默认值。
        """
        return pulumi.get(self, "default_value")

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

    @property
    @pulumi.getter(name="maxLength")
    def max_length(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        自定义参数值（字符串）的最大长度。
        """
        return pulumi.get(self, "max_length")

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

    @property
    @pulumi.getter(name="maxValue")
    def max_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        自定义参数值（数字）的最大值。
        """
        return pulumi.get(self, "max_value")

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

    @property
    @pulumi.getter(name="minLength")
    def min_length(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        自定义参数值（字符串）的最小长度。
        """
        return pulumi.get(self, "min_length")

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

    @property
    @pulumi.getter(name="minValue")
    def min_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        自定义参数值（数字）的最小值。
        """
        return pulumi.get(self, "min_value")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        自定义参数名称，需要在脚本中通过{{Param}}定义 。
        """
        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 required(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否必填。true：必填。false：非必填。
        """
        return pulumi.get(self, "required")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        自定义参数类型。String：表示自定义参数类型字符串类型。Digit：表示自定义参数类型为数值类型。
        """
        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 InvocationTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        用户标签的标签键。命名规则如下：不能以volc:或sys:的任意大小写组合开头。只能包含语言字符、数字、空格和英文符号“_”、“.”、“:”、“/”、“=”、“+”、“-”、“@”。长度限制在1～128个字符之间。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        用户标签的标签值。命名规则如下：只能包含语言字符、数字、空格和英文符号“_”、“.”、“:”、“/”、“=”、“+”、“-”、“@”。允许为空，长度限制在0～256个字符之间。
        """
elif False:
    InvocationTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InvocationTagArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] key: 用户标签的标签键。命名规则如下：不能以volc:或sys:的任意大小写组合开头。只能包含语言字符、数字、空格和英文符号“_”、“.”、“:”、“/”、“=”、“+”、“-”、“@”。长度限制在1～128个字符之间。
        :param pulumi.Input[builtins.str] value: 用户标签的标签值。命名规则如下：只能包含语言字符、数字、空格和英文符号“_”、“.”、“:”、“/”、“=”、“+”、“-”、“@”。允许为空，长度限制在0～256个字符之间。
        """
        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]]:
        """
        用户标签的标签键。命名规则如下：不能以volc:或sys:的任意大小写组合开头。只能包含语言字符、数字、空格和英文符号“_”、“.”、“:”、“/”、“=”、“+”、“-”、“@”。长度限制在1～128个字符之间。
        """
        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]]:
        """
        用户标签的标签值。命名规则如下：只能包含语言字符、数字、空格和英文符号“_”、“.”、“:”、“/”、“=”、“+”、“-”、“@”。允许为空，长度限制在0～256个字符之间。
        """
        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 KeypairTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        标签键。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        标签值。
        """
elif False:
    KeypairTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KeypairTagArgs:
    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 LaunchTemplateLaunchTemplateTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        给资源添加的用户标签的标签键。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        给资源添加的用户标签的标签值。
        """
elif False:
    LaunchTemplateLaunchTemplateTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LaunchTemplateLaunchTemplateTagArgs:
    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 LaunchTemplateLaunchTemplateVersionArgsDict(TypedDict):
        deployment_set_group_number: NotRequired[pulumi.Input[builtins.int]]
        """
        当ECS实例要加入或调整的部署集策略为部署集组高可用策略（AvailabilityGroup）时，可以通过该参数指定实例在部署集中的分组号。
        """
        deployment_set_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例需要加入的部署集ID。
        """
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的描述。
        """
        eip: NotRequired[pulumi.Input['LaunchTemplateLaunchTemplateVersionEipArgsDict']]
        """
        实例绑定的公网IP信息。
        """
        host_name: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的主机名。Linux系统的主机名长度限制为2～59个字符。Windows系统的主机名长度限制为2～10个字符。
        """
        hpc_cluster_id: NotRequired[pulumi.Input[builtins.str]]
        """
        当创建高性能计算GPU型实例时，请指定高性能计算集群ID。
        """
        image_id: NotRequired[pulumi.Input[builtins.str]]
        """
        镜像ID。
        """
        image_name: NotRequired[pulumi.Input[builtins.str]]
        """
        镜像名称。
        """
        instance_charge_type: NotRequired[pulumi.Input[builtins.str]]
        """
        实例和云盘的计费类型，取值：PostPaid：按量计费。PrePaid：包年包月。Esi：弹性预约实例。Segmented：时段型弹性预约实例。
        """
        instance_name: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的名称。
        """
        instance_type_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的规格。
        """
        keep_image_credential: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否保留镜像设置，取值：true：保留镜像设置，保留后将使用镜像预设的密码或密钥对登录实例。false（默认）：不保留镜像设置。
        """
        key_pair_name: NotRequired[pulumi.Input[builtins.str]]
        """
        实例绑定的密钥对。
        """
        network_interfaces: NotRequired[pulumi.Input[Sequence[pulumi.Input['LaunchTemplateLaunchTemplateVersionNetworkInterfaceArgsDict']]]]
        project_name: NotRequired[pulumi.Input[builtins.str]]
        """
        实例所属项目。
        """
        scheduled_instance: NotRequired[pulumi.Input['LaunchTemplateLaunchTemplateVersionScheduledInstanceArgsDict']]
        """
        弹性预约单信息。
        """
        security_enhancement_strategy: NotRequired[pulumi.Input[builtins.str]]
        """
        是否开启安全加固。Active:开启安全加固，仅对公共镜像生效。InActive:关闭安全加固，对所有镜像生效。
        """
        spot_price_limit: NotRequired[pulumi.Input[builtins.float]]
        """
        抢占式实例的每小时最高价格。
        """
        spot_strategy: NotRequired[pulumi.Input[builtins.str]]
        """
        按量计费的抢占式策略。取值：NoSpot：表示创建正常按量计费实例。SpotAsPriceGo：系统自动出价，跟随当前市场实际价格的抢占式实例。SpotWithPriceLimit：设置出价上限的抢占式实例。
        """
        suffix_index: NotRequired[pulumi.Input[builtins.int]]
        """
        有序后缀的起始序号。
        """
        tags: NotRequired[pulumi.Input[Sequence[pulumi.Input['LaunchTemplateLaunchTemplateVersionTagArgsDict']]]]
        unique_suffix: NotRequired[pulumi.Input[builtins.bool]]
        """
        表示当创建多台实例时，是否为Hostname和InstanceName自动添加有序后缀。
        """
        user_data: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的自定义数据。
        """
        version_description: NotRequired[pulumi.Input[builtins.str]]
        """
        模版版本描述。
        """
        volumes: NotRequired[pulumi.Input[Sequence[pulumi.Input['LaunchTemplateLaunchTemplateVersionVolumeArgsDict']]]]
        vpc_id: NotRequired[pulumi.Input[builtins.str]]
        """
        私有网络ID。
        """
        zone_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例所属可用区ID。
        """
elif False:
    LaunchTemplateLaunchTemplateVersionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LaunchTemplateLaunchTemplateVersionArgs:
    def __init__(__self__, *,
                 deployment_set_group_number: Optional[pulumi.Input[builtins.int]] = None,
                 deployment_set_id: Optional[pulumi.Input[builtins.str]] = None,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 eip: Optional[pulumi.Input['LaunchTemplateLaunchTemplateVersionEipArgs']] = None,
                 host_name: Optional[pulumi.Input[builtins.str]] = None,
                 hpc_cluster_id: Optional[pulumi.Input[builtins.str]] = None,
                 image_id: Optional[pulumi.Input[builtins.str]] = None,
                 image_name: Optional[pulumi.Input[builtins.str]] = None,
                 instance_charge_type: Optional[pulumi.Input[builtins.str]] = None,
                 instance_name: Optional[pulumi.Input[builtins.str]] = None,
                 instance_type_id: Optional[pulumi.Input[builtins.str]] = None,
                 keep_image_credential: Optional[pulumi.Input[builtins.bool]] = None,
                 key_pair_name: Optional[pulumi.Input[builtins.str]] = None,
                 network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['LaunchTemplateLaunchTemplateVersionNetworkInterfaceArgs']]]] = None,
                 project_name: Optional[pulumi.Input[builtins.str]] = None,
                 scheduled_instance: Optional[pulumi.Input['LaunchTemplateLaunchTemplateVersionScheduledInstanceArgs']] = None,
                 security_enhancement_strategy: Optional[pulumi.Input[builtins.str]] = None,
                 spot_price_limit: Optional[pulumi.Input[builtins.float]] = None,
                 spot_strategy: Optional[pulumi.Input[builtins.str]] = None,
                 suffix_index: Optional[pulumi.Input[builtins.int]] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input['LaunchTemplateLaunchTemplateVersionTagArgs']]]] = None,
                 unique_suffix: Optional[pulumi.Input[builtins.bool]] = None,
                 user_data: Optional[pulumi.Input[builtins.str]] = None,
                 version_description: Optional[pulumi.Input[builtins.str]] = None,
                 volumes: Optional[pulumi.Input[Sequence[pulumi.Input['LaunchTemplateLaunchTemplateVersionVolumeArgs']]]] = None,
                 vpc_id: Optional[pulumi.Input[builtins.str]] = None,
                 zone_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] deployment_set_group_number: 当ECS实例要加入或调整的部署集策略为部署集组高可用策略（AvailabilityGroup）时，可以通过该参数指定实例在部署集中的分组号。
        :param pulumi.Input[builtins.str] deployment_set_id: 实例需要加入的部署集ID。
        :param pulumi.Input[builtins.str] description: 实例的描述。
        :param pulumi.Input['LaunchTemplateLaunchTemplateVersionEipArgs'] eip: 实例绑定的公网IP信息。
        :param pulumi.Input[builtins.str] host_name: 实例的主机名。Linux系统的主机名长度限制为2～59个字符。Windows系统的主机名长度限制为2～10个字符。
        :param pulumi.Input[builtins.str] hpc_cluster_id: 当创建高性能计算GPU型实例时，请指定高性能计算集群ID。
        :param pulumi.Input[builtins.str] image_id: 镜像ID。
        :param pulumi.Input[builtins.str] image_name: 镜像名称。
        :param pulumi.Input[builtins.str] instance_charge_type: 实例和云盘的计费类型，取值：PostPaid：按量计费。PrePaid：包年包月。Esi：弹性预约实例。Segmented：时段型弹性预约实例。
        :param pulumi.Input[builtins.str] instance_name: 实例的名称。
        :param pulumi.Input[builtins.str] instance_type_id: 实例的规格。
        :param pulumi.Input[builtins.bool] keep_image_credential: 是否保留镜像设置，取值：true：保留镜像设置，保留后将使用镜像预设的密码或密钥对登录实例。false（默认）：不保留镜像设置。
        :param pulumi.Input[builtins.str] key_pair_name: 实例绑定的密钥对。
        :param pulumi.Input[builtins.str] project_name: 实例所属项目。
        :param pulumi.Input['LaunchTemplateLaunchTemplateVersionScheduledInstanceArgs'] scheduled_instance: 弹性预约单信息。
        :param pulumi.Input[builtins.str] security_enhancement_strategy: 是否开启安全加固。Active:开启安全加固，仅对公共镜像生效。InActive:关闭安全加固，对所有镜像生效。
        :param pulumi.Input[builtins.float] spot_price_limit: 抢占式实例的每小时最高价格。
        :param pulumi.Input[builtins.str] spot_strategy: 按量计费的抢占式策略。取值：NoSpot：表示创建正常按量计费实例。SpotAsPriceGo：系统自动出价，跟随当前市场实际价格的抢占式实例。SpotWithPriceLimit：设置出价上限的抢占式实例。
        :param pulumi.Input[builtins.int] suffix_index: 有序后缀的起始序号。
        :param pulumi.Input[builtins.bool] unique_suffix: 表示当创建多台实例时，是否为Hostname和InstanceName自动添加有序后缀。
        :param pulumi.Input[builtins.str] user_data: 实例的自定义数据。
        :param pulumi.Input[builtins.str] version_description: 模版版本描述。
        :param pulumi.Input[builtins.str] vpc_id: 私有网络ID。
        :param pulumi.Input[builtins.str] zone_id: 实例所属可用区ID。
        """
        if deployment_set_group_number is not None:
            pulumi.set(__self__, "deployment_set_group_number", deployment_set_group_number)
        if deployment_set_id is not None:
            pulumi.set(__self__, "deployment_set_id", deployment_set_id)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if eip is not None:
            pulumi.set(__self__, "eip", eip)
        if host_name is not None:
            pulumi.set(__self__, "host_name", host_name)
        if hpc_cluster_id is not None:
            pulumi.set(__self__, "hpc_cluster_id", hpc_cluster_id)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if image_name is not None:
            pulumi.set(__self__, "image_name", image_name)
        if instance_charge_type is not None:
            pulumi.set(__self__, "instance_charge_type", instance_charge_type)
        if instance_name is not None:
            pulumi.set(__self__, "instance_name", instance_name)
        if instance_type_id is not None:
            pulumi.set(__self__, "instance_type_id", instance_type_id)
        if keep_image_credential is not None:
            pulumi.set(__self__, "keep_image_credential", keep_image_credential)
        if key_pair_name is not None:
            pulumi.set(__self__, "key_pair_name", key_pair_name)
        if network_interfaces is not None:
            pulumi.set(__self__, "network_interfaces", network_interfaces)
        if project_name is not None:
            pulumi.set(__self__, "project_name", project_name)
        if scheduled_instance is not None:
            pulumi.set(__self__, "scheduled_instance", scheduled_instance)
        if security_enhancement_strategy is not None:
            pulumi.set(__self__, "security_enhancement_strategy", security_enhancement_strategy)
        if spot_price_limit is not None:
            pulumi.set(__self__, "spot_price_limit", spot_price_limit)
        if spot_strategy is not None:
            pulumi.set(__self__, "spot_strategy", spot_strategy)
        if suffix_index is not None:
            pulumi.set(__self__, "suffix_index", suffix_index)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if unique_suffix is not None:
            pulumi.set(__self__, "unique_suffix", unique_suffix)
        if user_data is not None:
            pulumi.set(__self__, "user_data", user_data)
        if version_description is not None:
            pulumi.set(__self__, "version_description", version_description)
        if volumes is not None:
            pulumi.set(__self__, "volumes", volumes)
        if vpc_id is not None:
            pulumi.set(__self__, "vpc_id", vpc_id)
        if zone_id is not None:
            pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter(name="deploymentSetGroupNumber")
    def deployment_set_group_number(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        当ECS实例要加入或调整的部署集策略为部署集组高可用策略（AvailabilityGroup）时，可以通过该参数指定实例在部署集中的分组号。
        """
        return pulumi.get(self, "deployment_set_group_number")

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

    @property
    @pulumi.getter(name="deploymentSetId")
    def deployment_set_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例需要加入的部署集ID。
        """
        return pulumi.get(self, "deployment_set_id")

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

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

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

    @property
    @pulumi.getter
    def eip(self) -> Optional[pulumi.Input['LaunchTemplateLaunchTemplateVersionEipArgs']]:
        """
        实例绑定的公网IP信息。
        """
        return pulumi.get(self, "eip")

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

    @property
    @pulumi.getter(name="hostName")
    def host_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例的主机名。Linux系统的主机名长度限制为2～59个字符。Windows系统的主机名长度限制为2～10个字符。
        """
        return pulumi.get(self, "host_name")

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

    @property
    @pulumi.getter(name="hpcClusterId")
    def hpc_cluster_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        当创建高性能计算GPU型实例时，请指定高性能计算集群ID。
        """
        return pulumi.get(self, "hpc_cluster_id")

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

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        镜像ID。
        """
        return pulumi.get(self, "image_id")

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

    @property
    @pulumi.getter(name="imageName")
    def image_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        镜像名称。
        """
        return pulumi.get(self, "image_name")

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

    @property
    @pulumi.getter(name="instanceChargeType")
    def instance_charge_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例和云盘的计费类型，取值：PostPaid：按量计费。PrePaid：包年包月。Esi：弹性预约实例。Segmented：时段型弹性预约实例。
        """
        return pulumi.get(self, "instance_charge_type")

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

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

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

    @property
    @pulumi.getter(name="instanceTypeId")
    def instance_type_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例的规格。
        """
        return pulumi.get(self, "instance_type_id")

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

    @property
    @pulumi.getter(name="keepImageCredential")
    def keep_image_credential(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否保留镜像设置，取值：true：保留镜像设置，保留后将使用镜像预设的密码或密钥对登录实例。false（默认）：不保留镜像设置。
        """
        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="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)

    @property
    @pulumi.getter(name="networkInterfaces")
    def network_interfaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LaunchTemplateLaunchTemplateVersionNetworkInterfaceArgs']]]]:
        return pulumi.get(self, "network_interfaces")

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

    @property
    @pulumi.getter(name="projectName")
    def project_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例所属项目。
        """
        return pulumi.get(self, "project_name")

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

    @property
    @pulumi.getter(name="scheduledInstance")
    def scheduled_instance(self) -> Optional[pulumi.Input['LaunchTemplateLaunchTemplateVersionScheduledInstanceArgs']]:
        """
        弹性预约单信息。
        """
        return pulumi.get(self, "scheduled_instance")

    @scheduled_instance.setter
    def scheduled_instance(self, value: Optional[pulumi.Input['LaunchTemplateLaunchTemplateVersionScheduledInstanceArgs']]):
        pulumi.set(self, "scheduled_instance", 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)

    @property
    @pulumi.getter(name="spotPriceLimit")
    def spot_price_limit(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        抢占式实例的每小时最高价格。
        """
        return pulumi.get(self, "spot_price_limit")

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

    @property
    @pulumi.getter(name="spotStrategy")
    def spot_strategy(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        按量计费的抢占式策略。取值：NoSpot：表示创建正常按量计费实例。SpotAsPriceGo：系统自动出价，跟随当前市场实际价格的抢占式实例。SpotWithPriceLimit：设置出价上限的抢占式实例。
        """
        return pulumi.get(self, "spot_strategy")

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

    @property
    @pulumi.getter(name="suffixIndex")
    def suffix_index(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        有序后缀的起始序号。
        """
        return pulumi.get(self, "suffix_index")

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

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

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

    @property
    @pulumi.getter(name="uniqueSuffix")
    def unique_suffix(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        表示当创建多台实例时，是否为Hostname和InstanceName自动添加有序后缀。
        """
        return pulumi.get(self, "unique_suffix")

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

    @property
    @pulumi.getter(name="userData")
    def user_data(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例的自定义数据。
        """
        return pulumi.get(self, "user_data")

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

    @property
    @pulumi.getter(name="versionDescription")
    def version_description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        模版版本描述。
        """
        return pulumi.get(self, "version_description")

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

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

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

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        私有网络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)

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例所属可用区ID。
        """
        return pulumi.get(self, "zone_id")

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


if not MYPY:
    class LaunchTemplateLaunchTemplateVersionEipArgsDict(TypedDict):
        bandwidth: NotRequired[pulumi.Input[builtins.int]]
        """
        公网IP的带宽上限，单位：Mbps。取值范围：1～200。默认值：1。
        """
        bandwidth_package_id: NotRequired[pulumi.Input[builtins.str]]
        """
        共享带宽包的ID，表示将公网IP加入到共享带宽包。
        """
        billing_type: NotRequired[pulumi.Input[builtins.int]]
        """
        公网IP的计费方式，取值：2：按量计费-按带宽上限计费。3：按量计费-按实际流量计费。
        """
        isp: NotRequired[pulumi.Input[builtins.str]]
        """
        公网IP的线路类型，取值：BGP：BGP（多线）。ChinaMobile：中国移动静态单线。ChinaTelecom：国电信静态单线。ChinaUnicom：中国联通静态单线。
        """
        release_with_instance: NotRequired[pulumi.Input[builtins.bool]]
        """
        公网IP是否随实例删除，仅按量计费公网IP生效。
        """
        security_protection_instance_id: NotRequired[pulumi.Input[builtins.int]]
        """
        安全防护包ID。
        """
        security_protection_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        公网IP的安全防护类型。取值：AntiDDoS_Enhanced：申请增强防护类型的公网IP，可加入到DDoS原生防护（企业版）实例。
        """
elif False:
    LaunchTemplateLaunchTemplateVersionEipArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LaunchTemplateLaunchTemplateVersionEipArgs:
    def __init__(__self__, *,
                 bandwidth: Optional[pulumi.Input[builtins.int]] = None,
                 bandwidth_package_id: Optional[pulumi.Input[builtins.str]] = None,
                 billing_type: Optional[pulumi.Input[builtins.int]] = None,
                 isp: Optional[pulumi.Input[builtins.str]] = None,
                 release_with_instance: Optional[pulumi.Input[builtins.bool]] = None,
                 security_protection_instance_id: Optional[pulumi.Input[builtins.int]] = None,
                 security_protection_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
        """
        :param pulumi.Input[builtins.int] bandwidth: 公网IP的带宽上限，单位：Mbps。取值范围：1～200。默认值：1。
        :param pulumi.Input[builtins.str] bandwidth_package_id: 共享带宽包的ID，表示将公网IP加入到共享带宽包。
        :param pulumi.Input[builtins.int] billing_type: 公网IP的计费方式，取值：2：按量计费-按带宽上限计费。3：按量计费-按实际流量计费。
        :param pulumi.Input[builtins.str] isp: 公网IP的线路类型，取值：BGP：BGP（多线）。ChinaMobile：中国移动静态单线。ChinaTelecom：国电信静态单线。ChinaUnicom：中国联通静态单线。
        :param pulumi.Input[builtins.bool] release_with_instance: 公网IP是否随实例删除，仅按量计费公网IP生效。
        :param pulumi.Input[builtins.int] security_protection_instance_id: 安全防护包ID。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_protection_types: 公网IP的安全防护类型。取值：AntiDDoS_Enhanced：申请增强防护类型的公网IP，可加入到DDoS原生防护（企业版）实例。
        """
        if bandwidth is not None:
            pulumi.set(__self__, "bandwidth", bandwidth)
        if bandwidth_package_id is not None:
            pulumi.set(__self__, "bandwidth_package_id", bandwidth_package_id)
        if billing_type is not None:
            pulumi.set(__self__, "billing_type", billing_type)
        if isp is not None:
            pulumi.set(__self__, "isp", isp)
        if release_with_instance is not None:
            pulumi.set(__self__, "release_with_instance", release_with_instance)
        if security_protection_instance_id is not None:
            pulumi.set(__self__, "security_protection_instance_id", security_protection_instance_id)
        if security_protection_types is not None:
            pulumi.set(__self__, "security_protection_types", security_protection_types)

    @property
    @pulumi.getter
    def bandwidth(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        公网IP的带宽上限，单位：Mbps。取值范围：1～200。默认值：1。
        """
        return pulumi.get(self, "bandwidth")

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

    @property
    @pulumi.getter(name="bandwidthPackageId")
    def bandwidth_package_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        共享带宽包的ID，表示将公网IP加入到共享带宽包。
        """
        return pulumi.get(self, "bandwidth_package_id")

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

    @property
    @pulumi.getter(name="billingType")
    def billing_type(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        公网IP的计费方式，取值：2：按量计费-按带宽上限计费。3：按量计费-按实际流量计费。
        """
        return pulumi.get(self, "billing_type")

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

    @property
    @pulumi.getter
    def isp(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        公网IP的线路类型，取值：BGP：BGP（多线）。ChinaMobile：中国移动静态单线。ChinaTelecom：国电信静态单线。ChinaUnicom：中国联通静态单线。
        """
        return pulumi.get(self, "isp")

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

    @property
    @pulumi.getter(name="releaseWithInstance")
    def release_with_instance(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        公网IP是否随实例删除，仅按量计费公网IP生效。
        """
        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)

    @property
    @pulumi.getter(name="securityProtectionInstanceId")
    def security_protection_instance_id(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        安全防护包ID。
        """
        return pulumi.get(self, "security_protection_instance_id")

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

    @property
    @pulumi.getter(name="securityProtectionTypes")
    def security_protection_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        公网IP的安全防护类型。取值：AntiDDoS_Enhanced：申请增强防护类型的公网IP，可加入到DDoS原生防护（企业版）实例。
        """
        return pulumi.get(self, "security_protection_types")

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


if not MYPY:
    class LaunchTemplateLaunchTemplateVersionNetworkInterfaceArgsDict(TypedDict):
        security_group_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        网卡关联的安全组ID。
        """
        subnet_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的私有网络子网ID。
        """
elif False:
    LaunchTemplateLaunchTemplateVersionNetworkInterfaceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LaunchTemplateLaunchTemplateVersionNetworkInterfaceArgs:
    def __init__(__self__, *,
                 security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 subnet_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。
        """
        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)

    @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)


if not MYPY:
    class LaunchTemplateLaunchTemplateVersionScheduledInstanceArgsDict(TypedDict):
        scheduled_instance_description: NotRequired[pulumi.Input[builtins.str]]
        """
        弹性预约单的描述。
        """
        scheduled_instance_name: NotRequired[pulumi.Input[builtins.str]]
        """
        弹性预约单的名称。
        """
elif False:
    LaunchTemplateLaunchTemplateVersionScheduledInstanceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LaunchTemplateLaunchTemplateVersionScheduledInstanceArgs:
    def __init__(__self__, *,
                 scheduled_instance_description: Optional[pulumi.Input[builtins.str]] = None,
                 scheduled_instance_name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] scheduled_instance_description: 弹性预约单的描述。
        :param pulumi.Input[builtins.str] scheduled_instance_name: 弹性预约单的名称。
        """
        if scheduled_instance_description is not None:
            pulumi.set(__self__, "scheduled_instance_description", scheduled_instance_description)
        if scheduled_instance_name is not None:
            pulumi.set(__self__, "scheduled_instance_name", scheduled_instance_name)

    @property
    @pulumi.getter(name="scheduledInstanceDescription")
    def scheduled_instance_description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        弹性预约单的描述。
        """
        return pulumi.get(self, "scheduled_instance_description")

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

    @property
    @pulumi.getter(name="scheduledInstanceName")
    def scheduled_instance_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        弹性预约单的名称。
        """
        return pulumi.get(self, "scheduled_instance_name")

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


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

@pulumi.input_type
class LaunchTemplateLaunchTemplateVersionTagArgs:
    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 LaunchTemplateLaunchTemplateVersionVolumeArgsDict(TypedDict):
        delete_with_instance: NotRequired[pulumi.Input[builtins.bool]]
        """
        云盘是否随实例释放。
        """
        extra_performance_iops: NotRequired[pulumi.Input[builtins.int]]
        """
        云盘额外IOPS性能大小，仅ESSD FlexPL数据盘支持，单位为次/秒。 ExtraPerformanceTypeId为Balance或IOPS时需设置该参数。各个类型的额外性能取值范围如下：IOPS型：1～50000。Balance型：1～50000。
        """
        extra_performance_throughput_mb: NotRequired[pulumi.Input[builtins.int]]
        """
        云盘额外吞吐性能大小，单位MB/s，仅ESSD FlexPL数据盘支持。 ExtraPerformanceTypeId为Throughput时需设置该参数。 取值范围：1～650。
        """
        extra_performance_type_id: NotRequired[pulumi.Input[builtins.str]]
        """
        云盘额外性能的类型，仅ESSD FlexPL数据盘支持。关于额外性能的更多介绍，请参见云盘额外性能。取值：Balance：均衡型额外性能。IOPS：IOPS型额外性能。Throughput：吞吐量型额外性能。
        """
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        云盘大小，单位为GB。系统盘：ESSD*PL0：20~2048 PTSSD：10~500。数据盘：ESSD*PL0：10~32768 PTSSD：20~8192
        """
        snapshot_id: NotRequired[pulumi.Input[builtins.str]]
        """
        使用快照创建云盘，仅支持创建数据盘。您可以调用DescribeSnapshots接口查询快照ID。
        """
        volume_type: NotRequired[pulumi.Input[builtins.str]]
        """
        云盘类型。ESSD_PL0：极速型SSD PL0。PTSSD：性能型SSD。
        """
elif False:
    LaunchTemplateLaunchTemplateVersionVolumeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LaunchTemplateLaunchTemplateVersionVolumeArgs:
    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_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.bool] delete_with_instance: 云盘是否随实例释放。
        :param pulumi.Input[builtins.int] extra_performance_iops: 云盘额外IOPS性能大小，仅ESSD FlexPL数据盘支持，单位为次/秒。 ExtraPerformanceTypeId为Balance或IOPS时需设置该参数。各个类型的额外性能取值范围如下：IOPS型：1～50000。Balance型：1～50000。
        :param pulumi.Input[builtins.int] extra_performance_throughput_mb: 云盘额外吞吐性能大小，单位MB/s，仅ESSD FlexPL数据盘支持。 ExtraPerformanceTypeId为Throughput时需设置该参数。 取值范围：1～650。
        :param pulumi.Input[builtins.str] extra_performance_type_id: 云盘额外性能的类型，仅ESSD FlexPL数据盘支持。关于额外性能的更多介绍，请参见云盘额外性能。取值：Balance：均衡型额外性能。IOPS：IOPS型额外性能。Throughput：吞吐量型额外性能。
        :param pulumi.Input[builtins.int] size: 云盘大小，单位为GB。系统盘：ESSD*PL0：20~2048 PTSSD：10~500。数据盘：ESSD*PL0：10~32768 PTSSD：20~8192
        :param pulumi.Input[builtins.str] snapshot_id: 使用快照创建云盘，仅支持创建数据盘。您可以调用DescribeSnapshots接口查询快照ID。
        :param pulumi.Input[builtins.str] volume_type: 云盘类型。ESSD_PL0：极速型SSD PL0。PTSSD：性能型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_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性能大小，仅ESSD FlexPL数据盘支持，单位为次/秒。 ExtraPerformanceTypeId为Balance或IOPS时需设置该参数。各个类型的额外性能取值范围如下：IOPS型：1～50000。Balance型：1～50000。
        """
        return pulumi.get(self, "extra_performance_iops")

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

    @property
    @pulumi.getter(name="extraPerformanceThroughputMb")
    def extra_performance_throughput_mb(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        云盘额外吞吐性能大小，单位MB/s，仅ESSD FlexPL数据盘支持。 ExtraPerformanceTypeId为Throughput时需设置该参数。 取值范围：1～650。
        """
        return pulumi.get(self, "extra_performance_throughput_mb")

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

    @property
    @pulumi.getter(name="extraPerformanceTypeId")
    def extra_performance_type_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        云盘额外性能的类型，仅ESSD FlexPL数据盘支持。关于额外性能的更多介绍，请参见云盘额外性能。取值：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]]:
        """
        云盘大小，单位为GB。系统盘：ESSD*PL0：20~2048 PTSSD：10~500。数据盘：ESSD*PL0：10~32768 PTSSD：20~8192
        """
        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]]:
        """
        使用快照创建云盘，仅支持创建数据盘。您可以调用DescribeSnapshots接口查询快照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="volumeType")
    def volume_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        云盘类型。ESSD_PL0：极速型SSD PL0。PTSSD：性能型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 LaunchTemplateVersionEipArgsDict(TypedDict):
        bandwidth: NotRequired[pulumi.Input[builtins.int]]
        """
        公网IP的带宽上限，单位：Mbps。取值范围：1～200。默认值：1。
        """
        bandwidth_package_id: NotRequired[pulumi.Input[builtins.str]]
        """
        共享带宽包的ID，表示将公网IP加入到共享带宽包。
        """
        billing_type: NotRequired[pulumi.Input[builtins.int]]
        """
        公网IP的计费方式，取值：2：按量计费-按带宽上限计费。3：按量计费-按实际流量计费。
        """
        isp: NotRequired[pulumi.Input[builtins.str]]
        """
        公网IP的线路类型，取值：BGP：BGP（多线）。ChinaMobile：中国移动静态单线。ChinaTelecom：国电信静态单线。ChinaUnicom：中国联通静态单线。
        """
        release_with_instance: NotRequired[pulumi.Input[builtins.bool]]
        """
        公网IP是否随实例删除，仅按量计费公网IP生效。
        """
        security_protection_instance_id: NotRequired[pulumi.Input[builtins.int]]
        """
        安全防护包ID。
        """
        security_protection_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        公网IP的安全防护类型。取值：AntiDDoS_Enhanced：申请增强防护类型的公网IP，可加入到DDoS原生防护（企业版）实例。
        """
elif False:
    LaunchTemplateVersionEipArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LaunchTemplateVersionEipArgs:
    def __init__(__self__, *,
                 bandwidth: Optional[pulumi.Input[builtins.int]] = None,
                 bandwidth_package_id: Optional[pulumi.Input[builtins.str]] = None,
                 billing_type: Optional[pulumi.Input[builtins.int]] = None,
                 isp: Optional[pulumi.Input[builtins.str]] = None,
                 release_with_instance: Optional[pulumi.Input[builtins.bool]] = None,
                 security_protection_instance_id: Optional[pulumi.Input[builtins.int]] = None,
                 security_protection_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
        """
        :param pulumi.Input[builtins.int] bandwidth: 公网IP的带宽上限，单位：Mbps。取值范围：1～200。默认值：1。
        :param pulumi.Input[builtins.str] bandwidth_package_id: 共享带宽包的ID，表示将公网IP加入到共享带宽包。
        :param pulumi.Input[builtins.int] billing_type: 公网IP的计费方式，取值：2：按量计费-按带宽上限计费。3：按量计费-按实际流量计费。
        :param pulumi.Input[builtins.str] isp: 公网IP的线路类型，取值：BGP：BGP（多线）。ChinaMobile：中国移动静态单线。ChinaTelecom：国电信静态单线。ChinaUnicom：中国联通静态单线。
        :param pulumi.Input[builtins.bool] release_with_instance: 公网IP是否随实例删除，仅按量计费公网IP生效。
        :param pulumi.Input[builtins.int] security_protection_instance_id: 安全防护包ID。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_protection_types: 公网IP的安全防护类型。取值：AntiDDoS_Enhanced：申请增强防护类型的公网IP，可加入到DDoS原生防护（企业版）实例。
        """
        if bandwidth is not None:
            pulumi.set(__self__, "bandwidth", bandwidth)
        if bandwidth_package_id is not None:
            pulumi.set(__self__, "bandwidth_package_id", bandwidth_package_id)
        if billing_type is not None:
            pulumi.set(__self__, "billing_type", billing_type)
        if isp is not None:
            pulumi.set(__self__, "isp", isp)
        if release_with_instance is not None:
            pulumi.set(__self__, "release_with_instance", release_with_instance)
        if security_protection_instance_id is not None:
            pulumi.set(__self__, "security_protection_instance_id", security_protection_instance_id)
        if security_protection_types is not None:
            pulumi.set(__self__, "security_protection_types", security_protection_types)

    @property
    @pulumi.getter
    def bandwidth(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        公网IP的带宽上限，单位：Mbps。取值范围：1～200。默认值：1。
        """
        return pulumi.get(self, "bandwidth")

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

    @property
    @pulumi.getter(name="bandwidthPackageId")
    def bandwidth_package_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        共享带宽包的ID，表示将公网IP加入到共享带宽包。
        """
        return pulumi.get(self, "bandwidth_package_id")

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

    @property
    @pulumi.getter(name="billingType")
    def billing_type(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        公网IP的计费方式，取值：2：按量计费-按带宽上限计费。3：按量计费-按实际流量计费。
        """
        return pulumi.get(self, "billing_type")

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

    @property
    @pulumi.getter
    def isp(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        公网IP的线路类型，取值：BGP：BGP（多线）。ChinaMobile：中国移动静态单线。ChinaTelecom：国电信静态单线。ChinaUnicom：中国联通静态单线。
        """
        return pulumi.get(self, "isp")

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

    @property
    @pulumi.getter(name="releaseWithInstance")
    def release_with_instance(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        公网IP是否随实例删除，仅按量计费公网IP生效。
        """
        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)

    @property
    @pulumi.getter(name="securityProtectionInstanceId")
    def security_protection_instance_id(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        安全防护包ID。
        """
        return pulumi.get(self, "security_protection_instance_id")

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

    @property
    @pulumi.getter(name="securityProtectionTypes")
    def security_protection_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        公网IP的安全防护类型。取值：AntiDDoS_Enhanced：申请增强防护类型的公网IP，可加入到DDoS原生防护（企业版）实例。
        """
        return pulumi.get(self, "security_protection_types")

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


if not MYPY:
    class LaunchTemplateVersionNetworkInterfaceArgsDict(TypedDict):
        security_group_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        网卡关联的安全组ID。
        """
        subnet_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的私有网络子网ID。
        """
elif False:
    LaunchTemplateVersionNetworkInterfaceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LaunchTemplateVersionNetworkInterfaceArgs:
    def __init__(__self__, *,
                 security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 subnet_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。
        """
        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)

    @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)


if not MYPY:
    class LaunchTemplateVersionScheduledInstanceArgsDict(TypedDict):
        scheduled_instance_description: NotRequired[pulumi.Input[builtins.str]]
        """
        弹性预约单的描述。
        """
        scheduled_instance_name: NotRequired[pulumi.Input[builtins.str]]
        """
        弹性预约单的名称。
        """
elif False:
    LaunchTemplateVersionScheduledInstanceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LaunchTemplateVersionScheduledInstanceArgs:
    def __init__(__self__, *,
                 scheduled_instance_description: Optional[pulumi.Input[builtins.str]] = None,
                 scheduled_instance_name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] scheduled_instance_description: 弹性预约单的描述。
        :param pulumi.Input[builtins.str] scheduled_instance_name: 弹性预约单的名称。
        """
        if scheduled_instance_description is not None:
            pulumi.set(__self__, "scheduled_instance_description", scheduled_instance_description)
        if scheduled_instance_name is not None:
            pulumi.set(__self__, "scheduled_instance_name", scheduled_instance_name)

    @property
    @pulumi.getter(name="scheduledInstanceDescription")
    def scheduled_instance_description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        弹性预约单的描述。
        """
        return pulumi.get(self, "scheduled_instance_description")

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

    @property
    @pulumi.getter(name="scheduledInstanceName")
    def scheduled_instance_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        弹性预约单的名称。
        """
        return pulumi.get(self, "scheduled_instance_name")

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


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

@pulumi.input_type
class LaunchTemplateVersionTagArgs:
    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 LaunchTemplateVersionVolumeArgsDict(TypedDict):
        delete_with_instance: NotRequired[pulumi.Input[builtins.bool]]
        """
        云盘是否随实例释放。
        """
        extra_performance_iops: NotRequired[pulumi.Input[builtins.int]]
        """
        云盘额外IOPS性能大小，仅ESSD FlexPL数据盘支持，单位为次/秒。 ExtraPerformanceTypeId为Balance或IOPS时需设置该参数。各个类型的额外性能取值范围如下：IOPS型：1～50000。Balance型：1～50000。
        """
        extra_performance_throughput_mb: NotRequired[pulumi.Input[builtins.int]]
        """
        云盘额外吞吐性能大小，单位MB/s，仅ESSD FlexPL数据盘支持。 ExtraPerformanceTypeId为Throughput时需设置该参数。 取值范围：1～650。
        """
        extra_performance_type_id: NotRequired[pulumi.Input[builtins.str]]
        """
        云盘额外性能的类型，仅ESSD FlexPL数据盘支持。关于额外性能的更多介绍，请参见云盘额外性能。取值：Balance：均衡型额外性能。IOPS：IOPS型额外性能。Throughput：吞吐量型额外性能。
        """
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        云盘大小，单位为GB。系统盘：ESSD*PL0：20~2048 PTSSD：10~500。数据盘：ESSD*PL0：10~32768 PTSSD：20~8192
        """
        snapshot_id: NotRequired[pulumi.Input[builtins.str]]
        """
        使用快照创建云盘，仅支持创建数据盘。您可以调用DescribeSnapshots接口查询快照ID。
        """
        volume_type: NotRequired[pulumi.Input[builtins.str]]
        """
        云盘类型。ESSD_PL0：极速型SSD PL0。PTSSD：性能型SSD。
        """
elif False:
    LaunchTemplateVersionVolumeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LaunchTemplateVersionVolumeArgs:
    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_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.bool] delete_with_instance: 云盘是否随实例释放。
        :param pulumi.Input[builtins.int] extra_performance_iops: 云盘额外IOPS性能大小，仅ESSD FlexPL数据盘支持，单位为次/秒。 ExtraPerformanceTypeId为Balance或IOPS时需设置该参数。各个类型的额外性能取值范围如下：IOPS型：1～50000。Balance型：1～50000。
        :param pulumi.Input[builtins.int] extra_performance_throughput_mb: 云盘额外吞吐性能大小，单位MB/s，仅ESSD FlexPL数据盘支持。 ExtraPerformanceTypeId为Throughput时需设置该参数。 取值范围：1～650。
        :param pulumi.Input[builtins.str] extra_performance_type_id: 云盘额外性能的类型，仅ESSD FlexPL数据盘支持。关于额外性能的更多介绍，请参见云盘额外性能。取值：Balance：均衡型额外性能。IOPS：IOPS型额外性能。Throughput：吞吐量型额外性能。
        :param pulumi.Input[builtins.int] size: 云盘大小，单位为GB。系统盘：ESSD*PL0：20~2048 PTSSD：10~500。数据盘：ESSD*PL0：10~32768 PTSSD：20~8192
        :param pulumi.Input[builtins.str] snapshot_id: 使用快照创建云盘，仅支持创建数据盘。您可以调用DescribeSnapshots接口查询快照ID。
        :param pulumi.Input[builtins.str] volume_type: 云盘类型。ESSD_PL0：极速型SSD PL0。PTSSD：性能型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_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性能大小，仅ESSD FlexPL数据盘支持，单位为次/秒。 ExtraPerformanceTypeId为Balance或IOPS时需设置该参数。各个类型的额外性能取值范围如下：IOPS型：1～50000。Balance型：1～50000。
        """
        return pulumi.get(self, "extra_performance_iops")

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

    @property
    @pulumi.getter(name="extraPerformanceThroughputMb")
    def extra_performance_throughput_mb(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        云盘额外吞吐性能大小，单位MB/s，仅ESSD FlexPL数据盘支持。 ExtraPerformanceTypeId为Throughput时需设置该参数。 取值范围：1～650。
        """
        return pulumi.get(self, "extra_performance_throughput_mb")

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

    @property
    @pulumi.getter(name="extraPerformanceTypeId")
    def extra_performance_type_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        云盘额外性能的类型，仅ESSD FlexPL数据盘支持。关于额外性能的更多介绍，请参见云盘额外性能。取值：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]]:
        """
        云盘大小，单位为GB。系统盘：ESSD*PL0：20~2048 PTSSD：10~500。数据盘：ESSD*PL0：10~32768 PTSSD：20~8192
        """
        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]]:
        """
        使用快照创建云盘，仅支持创建数据盘。您可以调用DescribeSnapshots接口查询快照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="volumeType")
    def volume_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        云盘类型。ESSD_PL0：极速型SSD PL0。PTSSD：性能型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)


