pulumi-alicloud 3.86.0a1758000634__py3-none-any.whl → 3.86.1__py3-none-any.whl

pulumi_alicloud/lindorm/outputs.py

@@ -13,11 +13,330 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
+from . import outputs
 
 __all__ = [
+    'InstanceV2EngineList',
+    'InstanceV2EngineListConnectAddressList',
+    'InstanceV2EngineListNodeGroup',
     'GetInstancesInstanceResult',
 ]
 
+@pulumi.output_type
+class InstanceV2EngineList(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "engineType":
+            suggest = "engine_type"
+        elif key == "connectAddressLists":
+            suggest = "connect_address_lists"
+        elif key == "isLastVersion":
+            suggest = "is_last_version"
+        elif key == "latestVersion":
+            suggest = "latest_version"
+        elif key == "nodeGroups":
+            suggest = "node_groups"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstanceV2EngineList. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceV2EngineList.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceV2EngineList.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 engine_type: _builtins.str,
+                 connect_address_lists: Optional[Sequence['outputs.InstanceV2EngineListConnectAddressList']] = None,
+                 is_last_version: Optional[_builtins.bool] = None,
+                 latest_version: Optional[_builtins.str] = None,
+                 node_groups: Optional[Sequence['outputs.InstanceV2EngineListNodeGroup']] = None,
+                 version: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str engine_type: Engine
+        :param Sequence['InstanceV2EngineListConnectAddressListArgs'] connect_address_lists: Connect Address List
+        :param _builtins.bool is_last_version: Whether it is the latest version
+        :param _builtins.str latest_version: Latest Version
+        :param Sequence['InstanceV2EngineListNodeGroupArgs'] node_groups: Node Group List See `node_group` below.
+        :param _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) -> _builtins.str:
+        """
+        Engine
+        """
+        return pulumi.get(self, "engine_type")
+
+    @_builtins.property
+    @pulumi.getter(name="connectAddressLists")
+    def connect_address_lists(self) -> Optional[Sequence['outputs.InstanceV2EngineListConnectAddressList']]:
+        """
+        Connect Address List
+        """
+        return pulumi.get(self, "connect_address_lists")
+
+    @_builtins.property
+    @pulumi.getter(name="isLastVersion")
+    def is_last_version(self) -> Optional[_builtins.bool]:
+        """
+        Whether it is the latest version
+        """
+        return pulumi.get(self, "is_last_version")
+
+    @_builtins.property
+    @pulumi.getter(name="latestVersion")
+    def latest_version(self) -> Optional[_builtins.str]:
+        """
+        Latest Version
+        """
+        return pulumi.get(self, "latest_version")
+
+    @_builtins.property
+    @pulumi.getter(name="nodeGroups")
+    def node_groups(self) -> Optional[Sequence['outputs.InstanceV2EngineListNodeGroup']]:
+        """
+        Node Group List See `node_group` below.
+        """
+        return pulumi.get(self, "node_groups")
+
+    @_builtins.property
+    @pulumi.getter
+    def version(self) -> Optional[_builtins.str]:
+        """
+        Engine Version
+        """
+        return pulumi.get(self, "version")
+
+
+@pulumi.output_type
+class InstanceV2EngineListConnectAddressList(dict):
+    def __init__(__self__, *,
+                 address: Optional[_builtins.str] = None,
+                 port: Optional[_builtins.str] = None,
+                 type: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str address: Connect Address
+        :param _builtins.str port: Connect Port
+        :param _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[_builtins.str]:
+        """
+        Connect Address
+        """
+        return pulumi.get(self, "address")
+
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> Optional[_builtins.str]:
+        """
+        Connect Port
+        """
+        return pulumi.get(self, "port")
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> Optional[_builtins.str]:
+        """
+        Connect Type:
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class InstanceV2EngineListNodeGroup(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "nodeCount":
+            suggest = "node_count"
+        elif key == "nodeSpec":
+            suggest = "node_spec"
+        elif key == "resourceGroupName":
+            suggest = "resource_group_name"
+        elif key == "cpuCoreCount":
+            suggest = "cpu_core_count"
+        elif key == "enableAttachLocalDisk":
+            suggest = "enable_attach_local_disk"
+        elif key == "memorySizeGiB":
+            suggest = "memory_size_gi_b"
+        elif key == "nodeDiskSize":
+            suggest = "node_disk_size"
+        elif key == "nodeDiskType":
+            suggest = "node_disk_type"
+        elif key == "specId":
+            suggest = "spec_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstanceV2EngineListNodeGroup. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceV2EngineListNodeGroup.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceV2EngineListNodeGroup.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 node_count: _builtins.int,
+                 node_spec: _builtins.str,
+                 resource_group_name: _builtins.str,
+                 category: Optional[_builtins.str] = None,
+                 cpu_core_count: Optional[_builtins.int] = None,
+                 enable_attach_local_disk: Optional[_builtins.bool] = None,
+                 memory_size_gi_b: Optional[_builtins.int] = None,
+                 node_disk_size: Optional[_builtins.int] = None,
+                 node_disk_type: Optional[_builtins.str] = None,
+                 spec_id: Optional[_builtins.str] = None,
+                 status: Optional[_builtins.str] = None):
+        """
+        :param _builtins.int node_count: Number of nodes
+        :param _builtins.str node_spec: Node Specifications
+        :param _builtins.str resource_group_name: Resource group name
+        :param _builtins.str category: Node Type
+        :param _builtins.int cpu_core_count: Number of CPU cores
+        :param _builtins.bool enable_attach_local_disk: Whether to mount  local cloud disks
+        :param _builtins.int memory_size_gi_b: Node memory size
+        :param _builtins.int node_disk_size: Local cloud disk storage capacity
+        :param _builtins.str node_disk_type: Node Disk Type
+        :param _builtins.str spec_id: Spec Id
+        :param _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) -> _builtins.int:
+        """
+        Number of nodes
+        """
+        return pulumi.get(self, "node_count")
+
+    @_builtins.property
+    @pulumi.getter(name="nodeSpec")
+    def node_spec(self) -> _builtins.str:
+        """
+        Node Specifications
+        """
+        return pulumi.get(self, "node_spec")
+
+    @_builtins.property
+    @pulumi.getter(name="resourceGroupName")
+    def resource_group_name(self) -> _builtins.str:
+        """
+        Resource group name
+        """
+        return pulumi.get(self, "resource_group_name")
+
+    @_builtins.property
+    @pulumi.getter
+    def category(self) -> Optional[_builtins.str]:
+        """
+        Node Type
+        """
+        return pulumi.get(self, "category")
+
+    @_builtins.property
+    @pulumi.getter(name="cpuCoreCount")
+    def cpu_core_count(self) -> Optional[_builtins.int]:
+        """
+        Number of CPU cores
+        """
+        return pulumi.get(self, "cpu_core_count")
+
+    @_builtins.property
+    @pulumi.getter(name="enableAttachLocalDisk")
+    def enable_attach_local_disk(self) -> Optional[_builtins.bool]:
+        """
+        Whether to mount  local cloud disks
+        """
+        return pulumi.get(self, "enable_attach_local_disk")
+
+    @_builtins.property
+    @pulumi.getter(name="memorySizeGiB")
+    def memory_size_gi_b(self) -> Optional[_builtins.int]:
+        """
+        Node memory size
+        """
+        return pulumi.get(self, "memory_size_gi_b")
+
+    @_builtins.property
+    @pulumi.getter(name="nodeDiskSize")
+    def node_disk_size(self) -> Optional[_builtins.int]:
+        """
+        Local cloud disk storage capacity
+        """
+        return pulumi.get(self, "node_disk_size")
+
+    @_builtins.property
+    @pulumi.getter(name="nodeDiskType")
+    def node_disk_type(self) -> Optional[_builtins.str]:
+        """
+        Node Disk Type
+        """
+        return pulumi.get(self, "node_disk_type")
+
+    @_builtins.property
+    @pulumi.getter(name="specId")
+    def spec_id(self) -> Optional[_builtins.str]:
+        """
+        Spec Id
+        """
+        return pulumi.get(self, "spec_id")
+
+    @_builtins.property
+    @pulumi.getter
+    def status(self) -> Optional[_builtins.str]:
+        """
+        Node Status
+        """
+        return pulumi.get(self, "status")
+
+
 @pulumi.output_type
 class GetInstancesInstanceResult(dict):
     def __init__(__self__, *,

pulumi_alicloud/log/etl.py

@@ -799,6 +799,9 @@ class Etl(pulumi.CustomResource):
         which is widely applicable to scenarios such as data regularization, enrichment, distribution, aggregation, and index reconstruction.
         [Refer to details](https://www.alibabacloud.com/help/zh/doc-detail/125384.htm).
 
+        > **NOTE:** This resource is no longer maintained. It is recommended to use the new resource alicloud_sls_etl.
+        Refer to details.
+
         > **NOTE:** Available since v1.120.0.
 
         ## Example Usage
@@ -914,6 +917,9 @@ class Etl(pulumi.CustomResource):
         which is widely applicable to scenarios such as data regularization, enrichment, distribution, aggregation, and index reconstruction.
         [Refer to details](https://www.alibabacloud.com/help/zh/doc-detail/125384.htm).
 
+        > **NOTE:** This resource is no longer maintained. It is recommended to use the new resource alicloud_sls_etl.
+        Refer to details.
+
         > **NOTE:** Available since v1.120.0.
 
         ## Example Usage