# coding=utf-8
# *** WARNING: this file was generated by pulumi-language-python. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import builtins as _builtins
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__ = [
    'InstanceV2EngineListArgs',
    'InstanceV2EngineListArgsDict',
    'InstanceV2EngineListConnectAddressListArgs',
    'InstanceV2EngineListConnectAddressListArgsDict',
    'InstanceV2EngineListNodeGroupArgs',
    'InstanceV2EngineListNodeGroupArgsDict',
]

MYPY = False

if not MYPY:
    class InstanceV2EngineListArgsDict(TypedDict):
        engine_type: pulumi.Input[_builtins.str]
        """
        Engine
        """
        connect_address_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstanceV2EngineListConnectAddressListArgsDict']]]]
        """
        Connect Address List
        """
        is_last_version: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether it is the latest version
        """
        latest_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Latest Version
        """
        node_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstanceV2EngineListNodeGroupArgsDict']]]]
        """
        Node Group List See `node_group` below.
        """
        version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Engine Version
        """
elif False:
    InstanceV2EngineListArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceV2EngineListArgs:
    def __init__(__self__, *,
                 engine_type: pulumi.Input[_builtins.str],
                 connect_address_lists: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceV2EngineListConnectAddressListArgs']]]] = None,
                 is_last_version: Optional[pulumi.Input[_builtins.bool]] = None,
                 latest_version: Optional[pulumi.Input[_builtins.str]] = None,
                 node_groups: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceV2EngineListNodeGroupArgs']]]] = None,
                 version: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] engine_type: Engine
        :param pulumi.Input[Sequence[pulumi.Input['InstanceV2EngineListConnectAddressListArgs']]] connect_address_lists: Connect Address List
        :param pulumi.Input[_builtins.bool] is_last_version: Whether it is the latest version
        :param pulumi.Input[_builtins.str] latest_version: Latest Version
        :param pulumi.Input[Sequence[pulumi.Input['InstanceV2EngineListNodeGroupArgs']]] node_groups: Node Group List See `node_group` below.
        :param pulumi.Input[_builtins.str] version: Engine Version
        """
        pulumi.set(__self__, "engine_type", engine_type)
        if connect_address_lists is not None:
            pulumi.set(__self__, "connect_address_lists", connect_address_lists)
        if is_last_version is not None:
            pulumi.set(__self__, "is_last_version", is_last_version)
        if latest_version is not None:
            pulumi.set(__self__, "latest_version", latest_version)
        if node_groups is not None:
            pulumi.set(__self__, "node_groups", node_groups)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @_builtins.property
    @pulumi.getter(name="engineType")
    def engine_type(self) -> pulumi.Input[_builtins.str]:
        """
        Engine
        """
        return pulumi.get(self, "engine_type")

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

    @_builtins.property
    @pulumi.getter(name="connectAddressLists")
    def connect_address_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceV2EngineListConnectAddressListArgs']]]]:
        """
        Connect Address List
        """
        return pulumi.get(self, "connect_address_lists")

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

    @_builtins.property
    @pulumi.getter(name="isLastVersion")
    def is_last_version(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether it is the latest version
        """
        return pulumi.get(self, "is_last_version")

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

    @_builtins.property
    @pulumi.getter(name="latestVersion")
    def latest_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Latest Version
        """
        return pulumi.get(self, "latest_version")

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

    @_builtins.property
    @pulumi.getter(name="nodeGroups")
    def node_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceV2EngineListNodeGroupArgs']]]]:
        """
        Node Group List See `node_group` below.
        """
        return pulumi.get(self, "node_groups")

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

    @_builtins.property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Engine Version
        """
        return pulumi.get(self, "version")

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


if not MYPY:
    class InstanceV2EngineListConnectAddressListArgsDict(TypedDict):
        address: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connect Address
        """
        port: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connect Port
        """
        type: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connect Type:
        """
elif False:
    InstanceV2EngineListConnectAddressListArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceV2EngineListConnectAddressListArgs:
    def __init__(__self__, *,
                 address: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.str]] = None,
                 type: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] address: Connect Address
        :param pulumi.Input[_builtins.str] port: Connect Port
        :param pulumi.Input[_builtins.str] type: Connect Type:
        """
        if address is not None:
            pulumi.set(__self__, "address", address)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @_builtins.property
    @pulumi.getter
    def address(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connect Address
        """
        return pulumi.get(self, "address")

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

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connect Port
        """
        return pulumi.get(self, "port")

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

    @_builtins.property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connect Type:
        """
        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 InstanceV2EngineListNodeGroupArgsDict(TypedDict):
        node_count: pulumi.Input[_builtins.int]
        """
        Number of nodes
        """
        node_spec: pulumi.Input[_builtins.str]
        """
        Node Specifications
        """
        resource_group_name: pulumi.Input[_builtins.str]
        """
        Resource group name
        """
        category: NotRequired[pulumi.Input[_builtins.str]]
        """
        Node Type
        """
        cpu_core_count: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of CPU cores
        """
        enable_attach_local_disk: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether to mount  local cloud disks
        """
        memory_size_gi_b: NotRequired[pulumi.Input[_builtins.int]]
        """
        Node memory size
        """
        node_disk_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Local cloud disk storage capacity
        """
        node_disk_type: NotRequired[pulumi.Input[_builtins.str]]
        """
        Node Disk Type
        """
        spec_id: NotRequired[pulumi.Input[_builtins.str]]
        """
        Spec Id
        """
        status: NotRequired[pulumi.Input[_builtins.str]]
        """
        Node Status
        """
elif False:
    InstanceV2EngineListNodeGroupArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceV2EngineListNodeGroupArgs:
    def __init__(__self__, *,
                 node_count: pulumi.Input[_builtins.int],
                 node_spec: pulumi.Input[_builtins.str],
                 resource_group_name: pulumi.Input[_builtins.str],
                 category: Optional[pulumi.Input[_builtins.str]] = None,
                 cpu_core_count: Optional[pulumi.Input[_builtins.int]] = None,
                 enable_attach_local_disk: Optional[pulumi.Input[_builtins.bool]] = None,
                 memory_size_gi_b: Optional[pulumi.Input[_builtins.int]] = None,
                 node_disk_size: Optional[pulumi.Input[_builtins.int]] = None,
                 node_disk_type: Optional[pulumi.Input[_builtins.str]] = None,
                 spec_id: Optional[pulumi.Input[_builtins.str]] = None,
                 status: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.int] node_count: Number of nodes
        :param pulumi.Input[_builtins.str] node_spec: Node Specifications
        :param pulumi.Input[_builtins.str] resource_group_name: Resource group name
        :param pulumi.Input[_builtins.str] category: Node Type
        :param pulumi.Input[_builtins.int] cpu_core_count: Number of CPU cores
        :param pulumi.Input[_builtins.bool] enable_attach_local_disk: Whether to mount  local cloud disks
        :param pulumi.Input[_builtins.int] memory_size_gi_b: Node memory size
        :param pulumi.Input[_builtins.int] node_disk_size: Local cloud disk storage capacity
        :param pulumi.Input[_builtins.str] node_disk_type: Node Disk Type
        :param pulumi.Input[_builtins.str] spec_id: Spec Id
        :param pulumi.Input[_builtins.str] status: Node Status
        """
        pulumi.set(__self__, "node_count", node_count)
        pulumi.set(__self__, "node_spec", node_spec)
        pulumi.set(__self__, "resource_group_name", resource_group_name)
        if category is not None:
            pulumi.set(__self__, "category", category)
        if cpu_core_count is not None:
            pulumi.set(__self__, "cpu_core_count", cpu_core_count)
        if enable_attach_local_disk is not None:
            pulumi.set(__self__, "enable_attach_local_disk", enable_attach_local_disk)
        if memory_size_gi_b is not None:
            pulumi.set(__self__, "memory_size_gi_b", memory_size_gi_b)
        if node_disk_size is not None:
            pulumi.set(__self__, "node_disk_size", node_disk_size)
        if node_disk_type is not None:
            pulumi.set(__self__, "node_disk_type", node_disk_type)
        if spec_id is not None:
            pulumi.set(__self__, "spec_id", spec_id)
        if status is not None:
            pulumi.set(__self__, "status", status)

    @_builtins.property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> pulumi.Input[_builtins.int]:
        """
        Number of nodes
        """
        return pulumi.get(self, "node_count")

    @node_count.setter
    def node_count(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "node_count", value)

    @_builtins.property
    @pulumi.getter(name="nodeSpec")
    def node_spec(self) -> pulumi.Input[_builtins.str]:
        """
        Node Specifications
        """
        return pulumi.get(self, "node_spec")

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

    @_builtins.property
    @pulumi.getter(name="resourceGroupName")
    def resource_group_name(self) -> pulumi.Input[_builtins.str]:
        """
        Resource group name
        """
        return pulumi.get(self, "resource_group_name")

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

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

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

    @_builtins.property
    @pulumi.getter(name="cpuCoreCount")
    def cpu_core_count(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of CPU cores
        """
        return pulumi.get(self, "cpu_core_count")

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

    @_builtins.property
    @pulumi.getter(name="enableAttachLocalDisk")
    def enable_attach_local_disk(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether to mount  local cloud disks
        """
        return pulumi.get(self, "enable_attach_local_disk")

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

    @_builtins.property
    @pulumi.getter(name="memorySizeGiB")
    def memory_size_gi_b(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Node memory size
        """
        return pulumi.get(self, "memory_size_gi_b")

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

    @_builtins.property
    @pulumi.getter(name="nodeDiskSize")
    def node_disk_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Local cloud disk storage capacity
        """
        return pulumi.get(self, "node_disk_size")

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

    @_builtins.property
    @pulumi.getter(name="nodeDiskType")
    def node_disk_type(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Node Disk Type
        """
        return pulumi.get(self, "node_disk_type")

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

    @_builtins.property
    @pulumi.getter(name="specId")
    def spec_id(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Spec Id
        """
        return pulumi.get(self, "spec_id")

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

    @_builtins.property
    @pulumi.getter
    def status(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Node Status
        """
        return pulumi.get(self, "status")

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


