pulumi-alicloud 3.85.0a1757389637__py3-none-any.whl → 3.86.0__py3-none-any.whl

pulumi_alicloud/fc/v3_function.py

@@ -43,6 +43,7 @@ class V3FunctionArgs:
                  memory_size: Optional[pulumi.Input[_builtins.int]] = None,
                  nas_config: Optional[pulumi.Input['V3FunctionNasConfigArgs']] = None,
                  oss_mount_config: Optional[pulumi.Input['V3FunctionOssMountConfigArgs']] = None,
+                 resource_group_id: Optional[pulumi.Input[_builtins.str]] = None,
                  role: Optional[pulumi.Input[_builtins.str]] = None,
                  session_affinity: Optional[pulumi.Input[_builtins.str]] = None,
                  session_affinity_config: Optional[pulumi.Input[_builtins.str]] = None,
@@ -52,7 +53,7 @@ class V3FunctionArgs:
         """
         The set of arguments for constructing a V3Function resource.
         :param pulumi.Input[_builtins.str] handler: Function Handler: the call entry for the function compute system to run your function.
-        :param pulumi.Input[_builtins.str] runtime: Function runtime type
+        :param pulumi.Input[_builtins.str] runtime: Function runtime type.
         :param pulumi.Input['V3FunctionCodeArgs'] code: Function code ZIP package. code and customContainerConfig. See `code` below.
         :param pulumi.Input[_builtins.float] cpu: The CPU specification of the function. The unit is vCPU, which is a multiple of the 0.05 vCPU.
         :param pulumi.Input['V3FunctionCustomContainerConfigArgs'] custom_container_config: The configuration of the custom container runtime. After the configuration is successful, the function can use the custom container image to execute the function. code and customContainerConfig. See `custom_container_config` below.
@@ -73,6 +74,7 @@ class V3FunctionArgs:
         :param pulumi.Input[_builtins.int] memory_size: The memory specification of the function. The unit is MB. The memory size is a multiple of 64MB. The minimum value is 128MB and the maximum value is 32GB. At the same time, the ratio of cpu to memorySize (calculated by GB) should be between 1:1 and 1:4.
         :param pulumi.Input['V3FunctionNasConfigArgs'] nas_config: NAS configuration. After this parameter is configured, the function can access the specified NAS resource. See `nas_config` below.
         :param pulumi.Input['V3FunctionOssMountConfigArgs'] oss_mount_config: OSS mount configuration See `oss_mount_config` below.
+        :param pulumi.Input[_builtins.str] resource_group_id: Resource Group ID.
         :param pulumi.Input[_builtins.str] role: The user is authorized to the RAM role of function compute. After the configuration, function compute will assume this role to generate temporary access credentials. In the function, you can use the temporary access credentials of the role to access the specified Alibaba cloud service, such as OSS and OTS
         :param pulumi.Input[_builtins.str] session_affinity: The affinity policy of the function compute call request. To implement the request affinity of the MCP SSE protocol, set it to MCP_SSE. If Cookie affinity is used, it can be set to GENERATED_COOKIE. If Header affinity is used, it can be set to HEADER_FIELD. If it is not set or set to NONE, the affinity effect is not set, and the request is routed according to the default scheduling policy of the function calculation system.
         :param pulumi.Input[_builtins.str] session_affinity_config: When you set the sessionAffinity affinity type, you need to set the relevant affinity configuration. For example, the MCP_SSE affinity needs to fill in the mcpssessionaffinityconfig configuration. The Cookie affinity needs to be filled with the CookieSessionAffinityConfig configuration, and the Header Field affinity needs to be filled with the HeaderFieldSessionAffinityConfig configuration.
@@ -122,6 +124,8 @@ class V3FunctionArgs:
             pulumi.set(__self__, "nas_config", nas_config)
         if oss_mount_config is not None:
             pulumi.set(__self__, "oss_mount_config", oss_mount_config)
+        if resource_group_id is not None:
+            pulumi.set(__self__, "resource_group_id", resource_group_id)
         if role is not None:
             pulumi.set(__self__, "role", role)
         if session_affinity is not None:
@@ -151,7 +155,7 @@ class V3FunctionArgs:
     @pulumi.getter
     def runtime(self) -> pulumi.Input[_builtins.str]:
         """
-        Function runtime type
+        Function runtime type.
         """
         return pulumi.get(self, "runtime")
 
@@ -399,6 +403,18 @@ class V3FunctionArgs:
     def oss_mount_config(self, value: Optional[pulumi.Input['V3FunctionOssMountConfigArgs']]):
         pulumi.set(self, "oss_mount_config", value)
 
+    @_builtins.property
+    @pulumi.getter(name="resourceGroupId")
+    def resource_group_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Resource Group ID.
+        """
+        return pulumi.get(self, "resource_group_id")
+
+    @resource_group_id.setter
+    def resource_group_id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "resource_group_id", value)
+
     @_builtins.property
     @pulumi.getter
     def role(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -504,6 +520,7 @@ class _V3FunctionState:
                  memory_size: Optional[pulumi.Input[_builtins.int]] = None,
                  nas_config: Optional[pulumi.Input['V3FunctionNasConfigArgs']] = None,
                  oss_mount_config: Optional[pulumi.Input['V3FunctionOssMountConfigArgs']] = None,
+                 resource_group_id: Optional[pulumi.Input[_builtins.str]] = None,
                  role: Optional[pulumi.Input[_builtins.str]] = None,
                  runtime: Optional[pulumi.Input[_builtins.str]] = None,
                  session_affinity: Optional[pulumi.Input[_builtins.str]] = None,
@@ -546,8 +563,9 @@ class _V3FunctionState:
         :param pulumi.Input[_builtins.int] memory_size: The memory specification of the function. The unit is MB. The memory size is a multiple of 64MB. The minimum value is 128MB and the maximum value is 32GB. At the same time, the ratio of cpu to memorySize (calculated by GB) should be between 1:1 and 1:4.
         :param pulumi.Input['V3FunctionNasConfigArgs'] nas_config: NAS configuration. After this parameter is configured, the function can access the specified NAS resource. See `nas_config` below.
         :param pulumi.Input['V3FunctionOssMountConfigArgs'] oss_mount_config: OSS mount configuration See `oss_mount_config` below.
+        :param pulumi.Input[_builtins.str] resource_group_id: Resource Group ID.
         :param pulumi.Input[_builtins.str] role: The user is authorized to the RAM role of function compute. After the configuration, function compute will assume this role to generate temporary access credentials. In the function, you can use the temporary access credentials of the role to access the specified Alibaba cloud service, such as OSS and OTS
-        :param pulumi.Input[_builtins.str] runtime: Function runtime type
+        :param pulumi.Input[_builtins.str] runtime: Function runtime type.
         :param pulumi.Input[_builtins.str] session_affinity: The affinity policy of the function compute call request. To implement the request affinity of the MCP SSE protocol, set it to MCP_SSE. If Cookie affinity is used, it can be set to GENERATED_COOKIE. If Header affinity is used, it can be set to HEADER_FIELD. If it is not set or set to NONE, the affinity effect is not set, and the request is routed according to the default scheduling policy of the function calculation system.
         :param pulumi.Input[_builtins.str] session_affinity_config: When you set the sessionAffinity affinity type, you need to set the relevant affinity configuration. For example, the MCP_SSE affinity needs to fill in the mcpssessionaffinityconfig configuration. The Cookie affinity needs to be filled with the CookieSessionAffinityConfig configuration, and the Header Field affinity needs to be filled with the HeaderFieldSessionAffinityConfig configuration.
         :param pulumi.Input[_builtins.str] state: Function Status
@@ -616,6 +634,8 @@ class _V3FunctionState:
             pulumi.set(__self__, "nas_config", nas_config)
         if oss_mount_config is not None:
             pulumi.set(__self__, "oss_mount_config", oss_mount_config)
+        if resource_group_id is not None:
+            pulumi.set(__self__, "resource_group_id", resource_group_id)
         if role is not None:
             pulumi.set(__self__, "role", role)
         if runtime is not None:
@@ -987,6 +1007,18 @@ class _V3FunctionState:
     def oss_mount_config(self, value: Optional[pulumi.Input['V3FunctionOssMountConfigArgs']]):
         pulumi.set(self, "oss_mount_config", value)
 
+    @_builtins.property
+    @pulumi.getter(name="resourceGroupId")
+    def resource_group_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Resource Group ID.
+        """
+        return pulumi.get(self, "resource_group_id")
+
+    @resource_group_id.setter
+    def resource_group_id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "resource_group_id", value)
+
     @_builtins.property
     @pulumi.getter
     def role(self) -> Optional[pulumi.Input[_builtins.str]]:
@@ -1003,7 +1035,7 @@ class _V3FunctionState:
     @pulumi.getter
     def runtime(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Function runtime type
+        Function runtime type.
         """
         return pulumi.get(self, "runtime")
 
@@ -1147,6 +1179,7 @@ class V3Function(pulumi.CustomResource):
                  memory_size: Optional[pulumi.Input[_builtins.int]] = None,
                  nas_config: Optional[pulumi.Input[Union['V3FunctionNasConfigArgs', 'V3FunctionNasConfigArgsDict']]] = None,
                  oss_mount_config: Optional[pulumi.Input[Union['V3FunctionOssMountConfigArgs', 'V3FunctionOssMountConfigArgsDict']]] = None,
+                 resource_group_id: Optional[pulumi.Input[_builtins.str]] = None,
                  role: Optional[pulumi.Input[_builtins.str]] = None,
                  runtime: Optional[pulumi.Input[_builtins.str]] = None,
                  session_affinity: Optional[pulumi.Input[_builtins.str]] = None,
@@ -1270,8 +1303,9 @@ class V3Function(pulumi.CustomResource):
         :param pulumi.Input[_builtins.int] memory_size: The memory specification of the function. The unit is MB. The memory size is a multiple of 64MB. The minimum value is 128MB and the maximum value is 32GB. At the same time, the ratio of cpu to memorySize (calculated by GB) should be between 1:1 and 1:4.
         :param pulumi.Input[Union['V3FunctionNasConfigArgs', 'V3FunctionNasConfigArgsDict']] nas_config: NAS configuration. After this parameter is configured, the function can access the specified NAS resource. See `nas_config` below.
         :param pulumi.Input[Union['V3FunctionOssMountConfigArgs', 'V3FunctionOssMountConfigArgsDict']] oss_mount_config: OSS mount configuration See `oss_mount_config` below.
+        :param pulumi.Input[_builtins.str] resource_group_id: Resource Group ID.
         :param pulumi.Input[_builtins.str] role: The user is authorized to the RAM role of function compute. After the configuration, function compute will assume this role to generate temporary access credentials. In the function, you can use the temporary access credentials of the role to access the specified Alibaba cloud service, such as OSS and OTS
-        :param pulumi.Input[_builtins.str] runtime: Function runtime type
+        :param pulumi.Input[_builtins.str] runtime: Function runtime type.
         :param pulumi.Input[_builtins.str] session_affinity: The affinity policy of the function compute call request. To implement the request affinity of the MCP SSE protocol, set it to MCP_SSE. If Cookie affinity is used, it can be set to GENERATED_COOKIE. If Header affinity is used, it can be set to HEADER_FIELD. If it is not set or set to NONE, the affinity effect is not set, and the request is routed according to the default scheduling policy of the function calculation system.
         :param pulumi.Input[_builtins.str] session_affinity_config: When you set the sessionAffinity affinity type, you need to set the relevant affinity configuration. For example, the MCP_SSE affinity needs to fill in the mcpssessionaffinityconfig configuration. The Cookie affinity needs to be filled with the CookieSessionAffinityConfig configuration, and the Header Field affinity needs to be filled with the HeaderFieldSessionAffinityConfig configuration.
         :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] tags: The tag of the resource
@@ -1412,6 +1446,7 @@ class V3Function(pulumi.CustomResource):
                  memory_size: Optional[pulumi.Input[_builtins.int]] = None,
                  nas_config: Optional[pulumi.Input[Union['V3FunctionNasConfigArgs', 'V3FunctionNasConfigArgsDict']]] = None,
                  oss_mount_config: Optional[pulumi.Input[Union['V3FunctionOssMountConfigArgs', 'V3FunctionOssMountConfigArgsDict']]] = None,
+                 resource_group_id: Optional[pulumi.Input[_builtins.str]] = None,
                  role: Optional[pulumi.Input[_builtins.str]] = None,
                  runtime: Optional[pulumi.Input[_builtins.str]] = None,
                  session_affinity: Optional[pulumi.Input[_builtins.str]] = None,
@@ -1451,6 +1486,7 @@ class V3Function(pulumi.CustomResource):
             __props__.__dict__["memory_size"] = memory_size
             __props__.__dict__["nas_config"] = nas_config
             __props__.__dict__["oss_mount_config"] = oss_mount_config
+            __props__.__dict__["resource_group_id"] = resource_group_id
             __props__.__dict__["role"] = role
             if runtime is None and not opts.urn:
                 raise TypeError("Missing required property 'runtime'")
@@ -1511,6 +1547,7 @@ class V3Function(pulumi.CustomResource):
             memory_size: Optional[pulumi.Input[_builtins.int]] = None,
             nas_config: Optional[pulumi.Input[Union['V3FunctionNasConfigArgs', 'V3FunctionNasConfigArgsDict']]] = None,
             oss_mount_config: Optional[pulumi.Input[Union['V3FunctionOssMountConfigArgs', 'V3FunctionOssMountConfigArgsDict']]] = None,
+            resource_group_id: Optional[pulumi.Input[_builtins.str]] = None,
             role: Optional[pulumi.Input[_builtins.str]] = None,
             runtime: Optional[pulumi.Input[_builtins.str]] = None,
             session_affinity: Optional[pulumi.Input[_builtins.str]] = None,
@@ -1558,8 +1595,9 @@ class V3Function(pulumi.CustomResource):
         :param pulumi.Input[_builtins.int] memory_size: The memory specification of the function. The unit is MB. The memory size is a multiple of 64MB. The minimum value is 128MB and the maximum value is 32GB. At the same time, the ratio of cpu to memorySize (calculated by GB) should be between 1:1 and 1:4.
         :param pulumi.Input[Union['V3FunctionNasConfigArgs', 'V3FunctionNasConfigArgsDict']] nas_config: NAS configuration. After this parameter is configured, the function can access the specified NAS resource. See `nas_config` below.
         :param pulumi.Input[Union['V3FunctionOssMountConfigArgs', 'V3FunctionOssMountConfigArgsDict']] oss_mount_config: OSS mount configuration See `oss_mount_config` below.
+        :param pulumi.Input[_builtins.str] resource_group_id: Resource Group ID.
         :param pulumi.Input[_builtins.str] role: The user is authorized to the RAM role of function compute. After the configuration, function compute will assume this role to generate temporary access credentials. In the function, you can use the temporary access credentials of the role to access the specified Alibaba cloud service, such as OSS and OTS
-        :param pulumi.Input[_builtins.str] runtime: Function runtime type
+        :param pulumi.Input[_builtins.str] runtime: Function runtime type.
         :param pulumi.Input[_builtins.str] session_affinity: The affinity policy of the function compute call request. To implement the request affinity of the MCP SSE protocol, set it to MCP_SSE. If Cookie affinity is used, it can be set to GENERATED_COOKIE. If Header affinity is used, it can be set to HEADER_FIELD. If it is not set or set to NONE, the affinity effect is not set, and the request is routed according to the default scheduling policy of the function calculation system.
         :param pulumi.Input[_builtins.str] session_affinity_config: When you set the sessionAffinity affinity type, you need to set the relevant affinity configuration. For example, the MCP_SSE affinity needs to fill in the mcpssessionaffinityconfig configuration. The Cookie affinity needs to be filled with the CookieSessionAffinityConfig configuration, and the Header Field affinity needs to be filled with the HeaderFieldSessionAffinityConfig configuration.
         :param pulumi.Input[_builtins.str] state: Function Status
@@ -1603,6 +1641,7 @@ class V3Function(pulumi.CustomResource):
         __props__.__dict__["memory_size"] = memory_size
         __props__.__dict__["nas_config"] = nas_config
         __props__.__dict__["oss_mount_config"] = oss_mount_config
+        __props__.__dict__["resource_group_id"] = resource_group_id
         __props__.__dict__["role"] = role
         __props__.__dict__["runtime"] = runtime
         __props__.__dict__["session_affinity"] = session_affinity
@@ -1848,6 +1887,14 @@ class V3Function(pulumi.CustomResource):
         """
         return pulumi.get(self, "oss_mount_config")
 
+    @_builtins.property
+    @pulumi.getter(name="resourceGroupId")
+    def resource_group_id(self) -> pulumi.Output[_builtins.str]:
+        """
+        Resource Group ID.
+        """
+        return pulumi.get(self, "resource_group_id")
+
     @_builtins.property
     @pulumi.getter
     def role(self) -> pulumi.Output[Optional[_builtins.str]]:
@@ -1860,7 +1907,7 @@ class V3Function(pulumi.CustomResource):
     @pulumi.getter
     def runtime(self) -> pulumi.Output[_builtins.str]:
         """
-        Function runtime type
+        Function runtime type.
         """
         return pulumi.get(self, "runtime")
 

pulumi_alicloud/lindorm/__init__.py

@@ -8,5 +8,7 @@ import typing
 # Export this package's modules as members:
 from .get_instances import *
 from .instance import *
+from .instance_v2 import *
 from .public_network import *
+from ._inputs import *
 from . import outputs

pulumi_alicloud/lindorm/_inputs.py

@@ -0,0 +1,459 @@
+# 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)
+
+