pulumi-alicloud 3.76.0a1743571220__py3-none-any.whl → 3.77.0a1744262757__py3-none-any.whl

pulumi_alicloud/eflo/outputs.py

@@ -13,12 +13,1378 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
+from . import outputs
 
 __all__ = [
+    'ClusterComponent',
+    'ClusterComponentComponentConfig',
+    'ClusterNetworks',
+    'ClusterNetworksIpAllocationPolicy',
+    'ClusterNetworksIpAllocationPolicyBondPolicy',
+    'ClusterNetworksIpAllocationPolicyBondPolicyBond',
+    'ClusterNetworksIpAllocationPolicyMachineTypePolicy',
+    'ClusterNetworksIpAllocationPolicyMachineTypePolicyBond',
+    'ClusterNetworksIpAllocationPolicyNodePolicy',
+    'ClusterNetworksIpAllocationPolicyNodePolicyBond',
+    'ClusterNetworksNewVpdInfo',
+    'ClusterNetworksNewVpdInfoVpdSubnet',
+    'ClusterNetworksVpdInfo',
+    'ClusterNodeGroup',
+    'ClusterNodeGroupNode',
+    'NodeGroupIpAllocationPolicy',
+    'NodeGroupIpAllocationPolicyBondPolicy',
+    'NodeGroupIpAllocationPolicyBondPolicyBond',
+    'NodeGroupIpAllocationPolicyMachineTypePolicy',
+    'NodeGroupIpAllocationPolicyMachineTypePolicyBond',
+    'NodeGroupIpAllocationPolicyNodePolicy',
+    'NodeGroupIpAllocationPolicyNodePolicyBond',
+    'NodeGroupNode',
     'GetSubnetsSubnetResult',
     'GetVpdsVpdResult',
 ]
 
+@pulumi.output_type
+class ClusterComponent(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "componentConfig":
+            suggest = "component_config"
+        elif key == "componentType":
+            suggest = "component_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterComponent. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterComponent.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterComponent.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 component_config: Optional['outputs.ClusterComponentComponentConfig'] = None,
+                 component_type: Optional[str] = None):
+        """
+        :param 'ClusterComponentComponentConfigArgs' component_config: Component Configuration See `component_config` below.
+        :param str component_type: Component Type
+        """
+        if component_config is not None:
+            pulumi.set(__self__, "component_config", component_config)
+        if component_type is not None:
+            pulumi.set(__self__, "component_type", component_type)
+
+    @property
+    @pulumi.getter(name="componentConfig")
+    def component_config(self) -> Optional['outputs.ClusterComponentComponentConfig']:
+        """
+        Component Configuration See `component_config` below.
+        """
+        return pulumi.get(self, "component_config")
+
+    @property
+    @pulumi.getter(name="componentType")
+    def component_type(self) -> Optional[str]:
+        """
+        Component Type
+        """
+        return pulumi.get(self, "component_type")
+
+
+@pulumi.output_type
+class ClusterComponentComponentConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "basicArgs":
+            suggest = "basic_args"
+        elif key == "nodeUnits":
+            suggest = "node_units"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterComponentComponentConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterComponentComponentConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterComponentComponentConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 basic_args: Optional[str] = None,
+                 node_units: Optional[Sequence[str]] = None):
+        """
+        :param str basic_args: Component Basic Parameters
+        :param Sequence[str] node_units: Node pool configuration, and is used to establish the corresponding relationship between node groups and node pools. When
+               ComponentType = "ACKEdge" is required. Other values are empty.
+        """
+        if basic_args is not None:
+            pulumi.set(__self__, "basic_args", basic_args)
+        if node_units is not None:
+            pulumi.set(__self__, "node_units", node_units)
+
+    @property
+    @pulumi.getter(name="basicArgs")
+    def basic_args(self) -> Optional[str]:
+        """
+        Component Basic Parameters
+        """
+        return pulumi.get(self, "basic_args")
+
+    @property
+    @pulumi.getter(name="nodeUnits")
+    def node_units(self) -> Optional[Sequence[str]]:
+        """
+        Node pool configuration, and is used to establish the corresponding relationship between node groups and node pools. When
+        ComponentType = "ACKEdge" is required. Other values are empty.
+        """
+        return pulumi.get(self, "node_units")
+
+
+@pulumi.output_type
+class ClusterNetworks(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "ipAllocationPolicies":
+            suggest = "ip_allocation_policies"
+        elif key == "newVpdInfo":
+            suggest = "new_vpd_info"
+        elif key == "securityGroupId":
+            suggest = "security_group_id"
+        elif key == "tailIpVersion":
+            suggest = "tail_ip_version"
+        elif key == "vpcId":
+            suggest = "vpc_id"
+        elif key == "vpdInfo":
+            suggest = "vpd_info"
+        elif key == "vswitchId":
+            suggest = "vswitch_id"
+        elif key == "vswitchZoneId":
+            suggest = "vswitch_zone_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNetworks. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNetworks.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNetworks.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 ip_allocation_policies: Optional[Sequence['outputs.ClusterNetworksIpAllocationPolicy']] = None,
+                 new_vpd_info: Optional['outputs.ClusterNetworksNewVpdInfo'] = None,
+                 security_group_id: Optional[str] = None,
+                 tail_ip_version: Optional[str] = None,
+                 vpc_id: Optional[str] = None,
+                 vpd_info: Optional['outputs.ClusterNetworksVpdInfo'] = None,
+                 vswitch_id: Optional[str] = None,
+                 vswitch_zone_id: Optional[str] = None):
+        """
+        :param Sequence['ClusterNetworksIpAllocationPolicyArgs'] ip_allocation_policies: IP allocation policy See `ip_allocation_policy` below.
+        :param 'ClusterNetworksNewVpdInfoArgs' new_vpd_info: Vpd configuration information See `new_vpd_info` below.
+        :param str security_group_id: Security group ID
+        :param str tail_ip_version: IP version
+        :param str vpc_id: VPC ID
+        :param 'ClusterNetworksVpdInfoArgs' vpd_info: Multiplexing VPD information See `vpd_info` below.
+        :param str vswitch_id: Switch ID
+        :param str vswitch_zone_id: Switch ZoneID
+        """
+        if ip_allocation_policies is not None:
+            pulumi.set(__self__, "ip_allocation_policies", ip_allocation_policies)
+        if new_vpd_info is not None:
+            pulumi.set(__self__, "new_vpd_info", new_vpd_info)
+        if security_group_id is not None:
+            pulumi.set(__self__, "security_group_id", security_group_id)
+        if tail_ip_version is not None:
+            pulumi.set(__self__, "tail_ip_version", tail_ip_version)
+        if vpc_id is not None:
+            pulumi.set(__self__, "vpc_id", vpc_id)
+        if vpd_info is not None:
+            pulumi.set(__self__, "vpd_info", vpd_info)
+        if vswitch_id is not None:
+            pulumi.set(__self__, "vswitch_id", vswitch_id)
+        if vswitch_zone_id is not None:
+            pulumi.set(__self__, "vswitch_zone_id", vswitch_zone_id)
+
+    @property
+    @pulumi.getter(name="ipAllocationPolicies")
+    def ip_allocation_policies(self) -> Optional[Sequence['outputs.ClusterNetworksIpAllocationPolicy']]:
+        """
+        IP allocation policy See `ip_allocation_policy` below.
+        """
+        return pulumi.get(self, "ip_allocation_policies")
+
+    @property
+    @pulumi.getter(name="newVpdInfo")
+    def new_vpd_info(self) -> Optional['outputs.ClusterNetworksNewVpdInfo']:
+        """
+        Vpd configuration information See `new_vpd_info` below.
+        """
+        return pulumi.get(self, "new_vpd_info")
+
+    @property
+    @pulumi.getter(name="securityGroupId")
+    def security_group_id(self) -> Optional[str]:
+        """
+        Security group ID
+        """
+        return pulumi.get(self, "security_group_id")
+
+    @property
+    @pulumi.getter(name="tailIpVersion")
+    def tail_ip_version(self) -> Optional[str]:
+        """
+        IP version
+        """
+        return pulumi.get(self, "tail_ip_version")
+
+    @property
+    @pulumi.getter(name="vpcId")
+    def vpc_id(self) -> Optional[str]:
+        """
+        VPC ID
+        """
+        return pulumi.get(self, "vpc_id")
+
+    @property
+    @pulumi.getter(name="vpdInfo")
+    def vpd_info(self) -> Optional['outputs.ClusterNetworksVpdInfo']:
+        """
+        Multiplexing VPD information See `vpd_info` below.
+        """
+        return pulumi.get(self, "vpd_info")
+
+    @property
+    @pulumi.getter(name="vswitchId")
+    def vswitch_id(self) -> Optional[str]:
+        """
+        Switch ID
+        """
+        return pulumi.get(self, "vswitch_id")
+
+    @property
+    @pulumi.getter(name="vswitchZoneId")
+    def vswitch_zone_id(self) -> Optional[str]:
+        """
+        Switch ZoneID
+        """
+        return pulumi.get(self, "vswitch_zone_id")
+
+
+@pulumi.output_type
+class ClusterNetworksIpAllocationPolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "bondPolicy":
+            suggest = "bond_policy"
+        elif key == "machineTypePolicies":
+            suggest = "machine_type_policies"
+        elif key == "nodePolicies":
+            suggest = "node_policies"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNetworksIpAllocationPolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNetworksIpAllocationPolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNetworksIpAllocationPolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bond_policy: Optional['outputs.ClusterNetworksIpAllocationPolicyBondPolicy'] = None,
+                 machine_type_policies: Optional[Sequence['outputs.ClusterNetworksIpAllocationPolicyMachineTypePolicy']] = None,
+                 node_policies: Optional[Sequence['outputs.ClusterNetworksIpAllocationPolicyNodePolicy']] = None):
+        """
+        :param 'ClusterNetworksIpAllocationPolicyBondPolicyArgs' bond_policy: Bond policy See `bond_policy` below.
+        :param Sequence['ClusterNetworksIpAllocationPolicyMachineTypePolicyArgs'] machine_type_policies: Model Assignment Policy See `machine_type_policy` below.
+        :param Sequence['ClusterNetworksIpAllocationPolicyNodePolicyArgs'] node_policies: Node allocation policy See `node_policy` below.
+        """
+        if bond_policy is not None:
+            pulumi.set(__self__, "bond_policy", bond_policy)
+        if machine_type_policies is not None:
+            pulumi.set(__self__, "machine_type_policies", machine_type_policies)
+        if node_policies is not None:
+            pulumi.set(__self__, "node_policies", node_policies)
+
+    @property
+    @pulumi.getter(name="bondPolicy")
+    def bond_policy(self) -> Optional['outputs.ClusterNetworksIpAllocationPolicyBondPolicy']:
+        """
+        Bond policy See `bond_policy` below.
+        """
+        return pulumi.get(self, "bond_policy")
+
+    @property
+    @pulumi.getter(name="machineTypePolicies")
+    def machine_type_policies(self) -> Optional[Sequence['outputs.ClusterNetworksIpAllocationPolicyMachineTypePolicy']]:
+        """
+        Model Assignment Policy See `machine_type_policy` below.
+        """
+        return pulumi.get(self, "machine_type_policies")
+
+    @property
+    @pulumi.getter(name="nodePolicies")
+    def node_policies(self) -> Optional[Sequence['outputs.ClusterNetworksIpAllocationPolicyNodePolicy']]:
+        """
+        Node allocation policy See `node_policy` below.
+        """
+        return pulumi.get(self, "node_policies")
+
+
+@pulumi.output_type
+class ClusterNetworksIpAllocationPolicyBondPolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "bondDefaultSubnet":
+            suggest = "bond_default_subnet"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNetworksIpAllocationPolicyBondPolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNetworksIpAllocationPolicyBondPolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNetworksIpAllocationPolicyBondPolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bond_default_subnet: Optional[str] = None,
+                 bonds: Optional[Sequence['outputs.ClusterNetworksIpAllocationPolicyBondPolicyBond']] = None):
+        """
+        :param str bond_default_subnet: Default bond cluster subnet
+        :param Sequence['ClusterNetworksIpAllocationPolicyBondPolicyBondArgs'] bonds: Bond information See `bonds` below.
+        """
+        if bond_default_subnet is not None:
+            pulumi.set(__self__, "bond_default_subnet", bond_default_subnet)
+        if bonds is not None:
+            pulumi.set(__self__, "bonds", bonds)
+
+    @property
+    @pulumi.getter(name="bondDefaultSubnet")
+    def bond_default_subnet(self) -> Optional[str]:
+        """
+        Default bond cluster subnet
+        """
+        return pulumi.get(self, "bond_default_subnet")
+
+    @property
+    @pulumi.getter
+    def bonds(self) -> Optional[Sequence['outputs.ClusterNetworksIpAllocationPolicyBondPolicyBond']]:
+        """
+        Bond information See `bonds` below.
+        """
+        return pulumi.get(self, "bonds")
+
+
+@pulumi.output_type
+class ClusterNetworksIpAllocationPolicyBondPolicyBond(dict):
+    def __init__(__self__, *,
+                 name: Optional[str] = None,
+                 subnet: Optional[str] = None):
+        """
+        :param str name: The bond name
+        :param str subnet: IP source cluster subnet
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if subnet is not None:
+            pulumi.set(__self__, "subnet", subnet)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        The bond name
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def subnet(self) -> Optional[str]:
+        """
+        IP source cluster subnet
+        """
+        return pulumi.get(self, "subnet")
+
+
+@pulumi.output_type
+class ClusterNetworksIpAllocationPolicyMachineTypePolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "machineType":
+            suggest = "machine_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNetworksIpAllocationPolicyMachineTypePolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNetworksIpAllocationPolicyMachineTypePolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNetworksIpAllocationPolicyMachineTypePolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bonds: Optional[Sequence['outputs.ClusterNetworksIpAllocationPolicyMachineTypePolicyBond']] = None,
+                 machine_type: Optional[str] = None):
+        """
+        :param Sequence['ClusterNetworksIpAllocationPolicyMachineTypePolicyBondArgs'] bonds: Bond information See `bonds` below.
+        """
+        if bonds is not None:
+            pulumi.set(__self__, "bonds", bonds)
+        if machine_type is not None:
+            pulumi.set(__self__, "machine_type", machine_type)
+
+    @property
+    @pulumi.getter
+    def bonds(self) -> Optional[Sequence['outputs.ClusterNetworksIpAllocationPolicyMachineTypePolicyBond']]:
+        """
+        Bond information See `bonds` below.
+        """
+        return pulumi.get(self, "bonds")
+
+    @property
+    @pulumi.getter(name="machineType")
+    def machine_type(self) -> Optional[str]:
+        return pulumi.get(self, "machine_type")
+
+
+@pulumi.output_type
+class ClusterNetworksIpAllocationPolicyMachineTypePolicyBond(dict):
+    def __init__(__self__, *,
+                 name: Optional[str] = None,
+                 subnet: Optional[str] = None):
+        """
+        :param str name: The bond name
+        :param str subnet: IP source cluster subnet
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if subnet is not None:
+            pulumi.set(__self__, "subnet", subnet)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        The bond name
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def subnet(self) -> Optional[str]:
+        """
+        IP source cluster subnet
+        """
+        return pulumi.get(self, "subnet")
+
+
+@pulumi.output_type
+class ClusterNetworksIpAllocationPolicyNodePolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "nodeId":
+            suggest = "node_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNetworksIpAllocationPolicyNodePolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNetworksIpAllocationPolicyNodePolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNetworksIpAllocationPolicyNodePolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bonds: Optional[Sequence['outputs.ClusterNetworksIpAllocationPolicyNodePolicyBond']] = None,
+                 node_id: Optional[str] = None):
+        """
+        :param Sequence['ClusterNetworksIpAllocationPolicyNodePolicyBondArgs'] bonds: Bond information See `bonds` below.
+        """
+        if bonds is not None:
+            pulumi.set(__self__, "bonds", bonds)
+        if node_id is not None:
+            pulumi.set(__self__, "node_id", node_id)
+
+    @property
+    @pulumi.getter
+    def bonds(self) -> Optional[Sequence['outputs.ClusterNetworksIpAllocationPolicyNodePolicyBond']]:
+        """
+        Bond information See `bonds` below.
+        """
+        return pulumi.get(self, "bonds")
+
+    @property
+    @pulumi.getter(name="nodeId")
+    def node_id(self) -> Optional[str]:
+        return pulumi.get(self, "node_id")
+
+
+@pulumi.output_type
+class ClusterNetworksIpAllocationPolicyNodePolicyBond(dict):
+    def __init__(__self__, *,
+                 name: Optional[str] = None,
+                 subnet: Optional[str] = None):
+        """
+        :param str name: The bond name
+        :param str subnet: IP source cluster subnet
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if subnet is not None:
+            pulumi.set(__self__, "subnet", subnet)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        The bond name
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def subnet(self) -> Optional[str]:
+        """
+        IP source cluster subnet
+        """
+        return pulumi.get(self, "subnet")
+
+
+@pulumi.output_type
+class ClusterNetworksNewVpdInfo(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "cenId":
+            suggest = "cen_id"
+        elif key == "cloudLinkCidr":
+            suggest = "cloud_link_cidr"
+        elif key == "cloudLinkId":
+            suggest = "cloud_link_id"
+        elif key == "monitorVpcId":
+            suggest = "monitor_vpc_id"
+        elif key == "monitorVswitchId":
+            suggest = "monitor_vswitch_id"
+        elif key == "vpdCidr":
+            suggest = "vpd_cidr"
+        elif key == "vpdSubnets":
+            suggest = "vpd_subnets"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNetworksNewVpdInfo. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNetworksNewVpdInfo.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNetworksNewVpdInfo.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 cen_id: Optional[str] = None,
+                 cloud_link_cidr: Optional[str] = None,
+                 cloud_link_id: Optional[str] = None,
+                 monitor_vpc_id: Optional[str] = None,
+                 monitor_vswitch_id: Optional[str] = None,
+                 vpd_cidr: Optional[str] = None,
+                 vpd_subnets: Optional[Sequence['outputs.ClusterNetworksNewVpdInfoVpdSubnet']] = None):
+        """
+        :param str cen_id: Cloud Enterprise Network ID
+        :param str cloud_link_cidr: Cloud chain cidr
+        :param str cloud_link_id: Cloud chain ID
+        :param str monitor_vpc_id: Proprietary Network
+        :param str monitor_vswitch_id: Proprietary network switch
+        :param str vpd_cidr: Cluster network segment
+        :param Sequence['ClusterNetworksNewVpdInfoVpdSubnetArgs'] vpd_subnets: List of cluster subnet ID
+        """
+        if cen_id is not None:
+            pulumi.set(__self__, "cen_id", cen_id)
+        if cloud_link_cidr is not None:
+            pulumi.set(__self__, "cloud_link_cidr", cloud_link_cidr)
+        if cloud_link_id is not None:
+            pulumi.set(__self__, "cloud_link_id", cloud_link_id)
+        if monitor_vpc_id is not None:
+            pulumi.set(__self__, "monitor_vpc_id", monitor_vpc_id)
+        if monitor_vswitch_id is not None:
+            pulumi.set(__self__, "monitor_vswitch_id", monitor_vswitch_id)
+        if vpd_cidr is not None:
+            pulumi.set(__self__, "vpd_cidr", vpd_cidr)
+        if vpd_subnets is not None:
+            pulumi.set(__self__, "vpd_subnets", vpd_subnets)
+
+    @property
+    @pulumi.getter(name="cenId")
+    def cen_id(self) -> Optional[str]:
+        """
+        Cloud Enterprise Network ID
+        """
+        return pulumi.get(self, "cen_id")
+
+    @property
+    @pulumi.getter(name="cloudLinkCidr")
+    def cloud_link_cidr(self) -> Optional[str]:
+        """
+        Cloud chain cidr
+        """
+        return pulumi.get(self, "cloud_link_cidr")
+
+    @property
+    @pulumi.getter(name="cloudLinkId")
+    def cloud_link_id(self) -> Optional[str]:
+        """
+        Cloud chain ID
+        """
+        return pulumi.get(self, "cloud_link_id")
+
+    @property
+    @pulumi.getter(name="monitorVpcId")
+    def monitor_vpc_id(self) -> Optional[str]:
+        """
+        Proprietary Network
+        """
+        return pulumi.get(self, "monitor_vpc_id")
+
+    @property
+    @pulumi.getter(name="monitorVswitchId")
+    def monitor_vswitch_id(self) -> Optional[str]:
+        """
+        Proprietary network switch
+        """
+        return pulumi.get(self, "monitor_vswitch_id")
+
+    @property
+    @pulumi.getter(name="vpdCidr")
+    def vpd_cidr(self) -> Optional[str]:
+        """
+        Cluster network segment
+        """
+        return pulumi.get(self, "vpd_cidr")
+
+    @property
+    @pulumi.getter(name="vpdSubnets")
+    def vpd_subnets(self) -> Optional[Sequence['outputs.ClusterNetworksNewVpdInfoVpdSubnet']]:
+        """
+        List of cluster subnet ID
+        """
+        return pulumi.get(self, "vpd_subnets")
+
+
+@pulumi.output_type
+class ClusterNetworksNewVpdInfoVpdSubnet(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "subnetCidr":
+            suggest = "subnet_cidr"
+        elif key == "subnetType":
+            suggest = "subnet_type"
+        elif key == "zoneId":
+            suggest = "zone_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNetworksNewVpdInfoVpdSubnet. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNetworksNewVpdInfoVpdSubnet.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNetworksNewVpdInfoVpdSubnet.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 subnet_cidr: Optional[str] = None,
+                 subnet_type: Optional[str] = None,
+                 zone_id: Optional[str] = None):
+        """
+        :param str subnet_cidr: Subnet cidr
+        :param str subnet_type: Subnet Type
+        """
+        if subnet_cidr is not None:
+            pulumi.set(__self__, "subnet_cidr", subnet_cidr)
+        if subnet_type is not None:
+            pulumi.set(__self__, "subnet_type", subnet_type)
+        if zone_id is not None:
+            pulumi.set(__self__, "zone_id", zone_id)
+
+    @property
+    @pulumi.getter(name="subnetCidr")
+    def subnet_cidr(self) -> Optional[str]:
+        """
+        Subnet cidr
+        """
+        return pulumi.get(self, "subnet_cidr")
+
+    @property
+    @pulumi.getter(name="subnetType")
+    def subnet_type(self) -> Optional[str]:
+        """
+        Subnet Type
+        """
+        return pulumi.get(self, "subnet_type")
+
+    @property
+    @pulumi.getter(name="zoneId")
+    def zone_id(self) -> Optional[str]:
+        return pulumi.get(self, "zone_id")
+
+
+@pulumi.output_type
+class ClusterNetworksVpdInfo(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "vpdId":
+            suggest = "vpd_id"
+        elif key == "vpdSubnets":
+            suggest = "vpd_subnets"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNetworksVpdInfo. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNetworksVpdInfo.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNetworksVpdInfo.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 vpd_id: Optional[str] = None,
+                 vpd_subnets: Optional[Sequence[str]] = None):
+        """
+        :param str vpd_id: VPC ID
+        :param Sequence[str] vpd_subnets: List of cluster subnet ID
+        """
+        if vpd_id is not None:
+            pulumi.set(__self__, "vpd_id", vpd_id)
+        if vpd_subnets is not None:
+            pulumi.set(__self__, "vpd_subnets", vpd_subnets)
+
+    @property
+    @pulumi.getter(name="vpdId")
+    def vpd_id(self) -> Optional[str]:
+        """
+        VPC ID
+        """
+        return pulumi.get(self, "vpd_id")
+
+    @property
+    @pulumi.getter(name="vpdSubnets")
+    def vpd_subnets(self) -> Optional[Sequence[str]]:
+        """
+        List of cluster subnet ID
+        """
+        return pulumi.get(self, "vpd_subnets")
+
+
+@pulumi.output_type
+class ClusterNodeGroup(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "imageId":
+            suggest = "image_id"
+        elif key == "machineType":
+            suggest = "machine_type"
+        elif key == "nodeGroupDescription":
+            suggest = "node_group_description"
+        elif key == "nodeGroupName":
+            suggest = "node_group_name"
+        elif key == "userData":
+            suggest = "user_data"
+        elif key == "zoneId":
+            suggest = "zone_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeGroup. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeGroup.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeGroup.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 image_id: Optional[str] = None,
+                 machine_type: Optional[str] = None,
+                 node_group_description: Optional[str] = None,
+                 node_group_name: Optional[str] = None,
+                 nodes: Optional[Sequence['outputs.ClusterNodeGroupNode']] = None,
+                 user_data: Optional[str] = None,
+                 zone_id: Optional[str] = None):
+        """
+        :param str image_id: System Image ID
+        :param str machine_type: Model
+        :param str node_group_description: Node Group Description
+        :param str node_group_name: Node Group Name
+        :param Sequence['ClusterNodeGroupNodeArgs'] nodes: Node List See `nodes` below.
+        :param str user_data: Instance custom data. It needs to be encoded in Base64 mode, and the original data is at most 16KB.
+        :param str zone_id: Zone ID
+        """
+        if image_id is not None:
+            pulumi.set(__self__, "image_id", image_id)
+        if machine_type is not None:
+            pulumi.set(__self__, "machine_type", machine_type)
+        if node_group_description is not None:
+            pulumi.set(__self__, "node_group_description", node_group_description)
+        if node_group_name is not None:
+            pulumi.set(__self__, "node_group_name", node_group_name)
+        if nodes is not None:
+            pulumi.set(__self__, "nodes", nodes)
+        if user_data is not None:
+            pulumi.set(__self__, "user_data", user_data)
+        if zone_id is not None:
+            pulumi.set(__self__, "zone_id", zone_id)
+
+    @property
+    @pulumi.getter(name="imageId")
+    def image_id(self) -> Optional[str]:
+        """
+        System Image ID
+        """
+        return pulumi.get(self, "image_id")
+
+    @property
+    @pulumi.getter(name="machineType")
+    def machine_type(self) -> Optional[str]:
+        """
+        Model
+        """
+        return pulumi.get(self, "machine_type")
+
+    @property
+    @pulumi.getter(name="nodeGroupDescription")
+    def node_group_description(self) -> Optional[str]:
+        """
+        Node Group Description
+        """
+        return pulumi.get(self, "node_group_description")
+
+    @property
+    @pulumi.getter(name="nodeGroupName")
+    def node_group_name(self) -> Optional[str]:
+        """
+        Node Group Name
+        """
+        return pulumi.get(self, "node_group_name")
+
+    @property
+    @pulumi.getter
+    def nodes(self) -> Optional[Sequence['outputs.ClusterNodeGroupNode']]:
+        """
+        Node List See `nodes` below.
+        """
+        return pulumi.get(self, "nodes")
+
+    @property
+    @pulumi.getter(name="userData")
+    def user_data(self) -> Optional[str]:
+        """
+        Instance custom data. It needs to be encoded in Base64 mode, and the original data is at most 16KB.
+        """
+        return pulumi.get(self, "user_data")
+
+    @property
+    @pulumi.getter(name="zoneId")
+    def zone_id(self) -> Optional[str]:
+        """
+        Zone ID
+        """
+        return pulumi.get(self, "zone_id")
+
+
+@pulumi.output_type
+class ClusterNodeGroupNode(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "loginPassword":
+            suggest = "login_password"
+        elif key == "nodeId":
+            suggest = "node_id"
+        elif key == "vpcId":
+            suggest = "vpc_id"
+        elif key == "vswitchId":
+            suggest = "vswitch_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeGroupNode. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeGroupNode.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeGroupNode.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 hostname: Optional[str] = None,
+                 login_password: Optional[str] = None,
+                 node_id: Optional[str] = None,
+                 vpc_id: Optional[str] = None,
+                 vswitch_id: Optional[str] = None):
+        """
+        :param str hostname: Host name
+        :param str login_password: Login Password
+        """
+        if hostname is not None:
+            pulumi.set(__self__, "hostname", hostname)
+        if login_password is not None:
+            pulumi.set(__self__, "login_password", login_password)
+        if node_id is not None:
+            pulumi.set(__self__, "node_id", node_id)
+        if vpc_id is not None:
+            pulumi.set(__self__, "vpc_id", vpc_id)
+        if vswitch_id is not None:
+            pulumi.set(__self__, "vswitch_id", vswitch_id)
+
+    @property
+    @pulumi.getter
+    def hostname(self) -> Optional[str]:
+        """
+        Host name
+        """
+        return pulumi.get(self, "hostname")
+
+    @property
+    @pulumi.getter(name="loginPassword")
+    def login_password(self) -> Optional[str]:
+        """
+        Login Password
+        """
+        return pulumi.get(self, "login_password")
+
+    @property
+    @pulumi.getter(name="nodeId")
+    def node_id(self) -> Optional[str]:
+        return pulumi.get(self, "node_id")
+
+    @property
+    @pulumi.getter(name="vpcId")
+    def vpc_id(self) -> Optional[str]:
+        return pulumi.get(self, "vpc_id")
+
+    @property
+    @pulumi.getter(name="vswitchId")
+    def vswitch_id(self) -> Optional[str]:
+        return pulumi.get(self, "vswitch_id")
+
+
+@pulumi.output_type
+class NodeGroupIpAllocationPolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "bondPolicy":
+            suggest = "bond_policy"
+        elif key == "machineTypePolicies":
+            suggest = "machine_type_policies"
+        elif key == "nodePolicies":
+            suggest = "node_policies"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodeGroupIpAllocationPolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodeGroupIpAllocationPolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodeGroupIpAllocationPolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bond_policy: Optional['outputs.NodeGroupIpAllocationPolicyBondPolicy'] = None,
+                 machine_type_policies: Optional[Sequence['outputs.NodeGroupIpAllocationPolicyMachineTypePolicy']] = None,
+                 node_policies: Optional[Sequence['outputs.NodeGroupIpAllocationPolicyNodePolicy']] = None):
+        """
+        :param 'NodeGroupIpAllocationPolicyBondPolicyArgs' bond_policy: Specify the cluster subnet ID based on the bond name See `bond_policy` below.
+        :param Sequence['NodeGroupIpAllocationPolicyMachineTypePolicyArgs'] machine_type_policies: Model Assignment Policy See `machine_type_policy` below.
+        :param Sequence['NodeGroupIpAllocationPolicyNodePolicyArgs'] node_policies: Node allocation policy See `node_policy` below.
+        """
+        if bond_policy is not None:
+            pulumi.set(__self__, "bond_policy", bond_policy)
+        if machine_type_policies is not None:
+            pulumi.set(__self__, "machine_type_policies", machine_type_policies)
+        if node_policies is not None:
+            pulumi.set(__self__, "node_policies", node_policies)
+
+    @property
+    @pulumi.getter(name="bondPolicy")
+    def bond_policy(self) -> Optional['outputs.NodeGroupIpAllocationPolicyBondPolicy']:
+        """
+        Specify the cluster subnet ID based on the bond name See `bond_policy` below.
+        """
+        return pulumi.get(self, "bond_policy")
+
+    @property
+    @pulumi.getter(name="machineTypePolicies")
+    def machine_type_policies(self) -> Optional[Sequence['outputs.NodeGroupIpAllocationPolicyMachineTypePolicy']]:
+        """
+        Model Assignment Policy See `machine_type_policy` below.
+        """
+        return pulumi.get(self, "machine_type_policies")
+
+    @property
+    @pulumi.getter(name="nodePolicies")
+    def node_policies(self) -> Optional[Sequence['outputs.NodeGroupIpAllocationPolicyNodePolicy']]:
+        """
+        Node allocation policy See `node_policy` below.
+        """
+        return pulumi.get(self, "node_policies")
+
+
+@pulumi.output_type
+class NodeGroupIpAllocationPolicyBondPolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "bondDefaultSubnet":
+            suggest = "bond_default_subnet"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodeGroupIpAllocationPolicyBondPolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodeGroupIpAllocationPolicyBondPolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodeGroupIpAllocationPolicyBondPolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bond_default_subnet: Optional[str] = None,
+                 bonds: Optional[Sequence['outputs.NodeGroupIpAllocationPolicyBondPolicyBond']] = None):
+        """
+        :param str bond_default_subnet: Default bond cluster subnet
+        :param Sequence['NodeGroupIpAllocationPolicyBondPolicyBondArgs'] bonds: Bond information See `bonds` below.
+        """
+        if bond_default_subnet is not None:
+            pulumi.set(__self__, "bond_default_subnet", bond_default_subnet)
+        if bonds is not None:
+            pulumi.set(__self__, "bonds", bonds)
+
+    @property
+    @pulumi.getter(name="bondDefaultSubnet")
+    def bond_default_subnet(self) -> Optional[str]:
+        """
+        Default bond cluster subnet
+        """
+        return pulumi.get(self, "bond_default_subnet")
+
+    @property
+    @pulumi.getter
+    def bonds(self) -> Optional[Sequence['outputs.NodeGroupIpAllocationPolicyBondPolicyBond']]:
+        """
+        Bond information See `bonds` below.
+        """
+        return pulumi.get(self, "bonds")
+
+
+@pulumi.output_type
+class NodeGroupIpAllocationPolicyBondPolicyBond(dict):
+    def __init__(__self__, *,
+                 name: Optional[str] = None,
+                 subnet: Optional[str] = None):
+        """
+        :param str name: The bond name
+        :param str subnet: IP source cluster subnet
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if subnet is not None:
+            pulumi.set(__self__, "subnet", subnet)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        The bond name
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def subnet(self) -> Optional[str]:
+        """
+        IP source cluster subnet
+        """
+        return pulumi.get(self, "subnet")
+
+
+@pulumi.output_type
+class NodeGroupIpAllocationPolicyMachineTypePolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "machineType":
+            suggest = "machine_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodeGroupIpAllocationPolicyMachineTypePolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodeGroupIpAllocationPolicyMachineTypePolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodeGroupIpAllocationPolicyMachineTypePolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bonds: Optional[Sequence['outputs.NodeGroupIpAllocationPolicyMachineTypePolicyBond']] = None,
+                 machine_type: Optional[str] = None):
+        """
+        :param Sequence['NodeGroupIpAllocationPolicyMachineTypePolicyBondArgs'] bonds: Bond information See `bonds` below.
+        :param str machine_type: Machine type
+        """
+        if bonds is not None:
+            pulumi.set(__self__, "bonds", bonds)
+        if machine_type is not None:
+            pulumi.set(__self__, "machine_type", machine_type)
+
+    @property
+    @pulumi.getter
+    def bonds(self) -> Optional[Sequence['outputs.NodeGroupIpAllocationPolicyMachineTypePolicyBond']]:
+        """
+        Bond information See `bonds` below.
+        """
+        return pulumi.get(self, "bonds")
+
+    @property
+    @pulumi.getter(name="machineType")
+    def machine_type(self) -> Optional[str]:
+        """
+        Machine type
+        """
+        return pulumi.get(self, "machine_type")
+
+
+@pulumi.output_type
+class NodeGroupIpAllocationPolicyMachineTypePolicyBond(dict):
+    def __init__(__self__, *,
+                 name: Optional[str] = None,
+                 subnet: Optional[str] = None):
+        """
+        :param str name: The bond name
+        :param str subnet: IP source cluster subnet
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if subnet is not None:
+            pulumi.set(__self__, "subnet", subnet)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        The bond name
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def subnet(self) -> Optional[str]:
+        """
+        IP source cluster subnet
+        """
+        return pulumi.get(self, "subnet")
+
+
+@pulumi.output_type
+class NodeGroupIpAllocationPolicyNodePolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "nodeId":
+            suggest = "node_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodeGroupIpAllocationPolicyNodePolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodeGroupIpAllocationPolicyNodePolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodeGroupIpAllocationPolicyNodePolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bonds: Optional[Sequence['outputs.NodeGroupIpAllocationPolicyNodePolicyBond']] = None,
+                 node_id: Optional[str] = None):
+        """
+        :param Sequence['NodeGroupIpAllocationPolicyNodePolicyBondArgs'] bonds: Bond information See `bonds` below.
+        """
+        if bonds is not None:
+            pulumi.set(__self__, "bonds", bonds)
+        if node_id is not None:
+            pulumi.set(__self__, "node_id", node_id)
+
+    @property
+    @pulumi.getter
+    def bonds(self) -> Optional[Sequence['outputs.NodeGroupIpAllocationPolicyNodePolicyBond']]:
+        """
+        Bond information See `bonds` below.
+        """
+        return pulumi.get(self, "bonds")
+
+    @property
+    @pulumi.getter(name="nodeId")
+    def node_id(self) -> Optional[str]:
+        return pulumi.get(self, "node_id")
+
+
+@pulumi.output_type
+class NodeGroupIpAllocationPolicyNodePolicyBond(dict):
+    def __init__(__self__, *,
+                 name: Optional[str] = None,
+                 subnet: Optional[str] = None):
+        """
+        :param str name: The bond name
+        :param str subnet: IP source cluster subnet
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if subnet is not None:
+            pulumi.set(__self__, "subnet", subnet)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        The bond name
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def subnet(self) -> Optional[str]:
+        """
+        IP source cluster subnet
+        """
+        return pulumi.get(self, "subnet")
+
+
+@pulumi.output_type
+class NodeGroupNode(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "loginPassword":
+            suggest = "login_password"
+        elif key == "nodeId":
+            suggest = "node_id"
+        elif key == "vpcId":
+            suggest = "vpc_id"
+        elif key == "vswitchId":
+            suggest = "vswitch_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodeGroupNode. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodeGroupNode.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodeGroupNode.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 hostname: Optional[str] = None,
+                 login_password: Optional[str] = None,
+                 node_id: Optional[str] = None,
+                 vpc_id: Optional[str] = None,
+                 vswitch_id: Optional[str] = None):
+        """
+        :param str hostname: Host name
+        :param str login_password: Login Password
+        :param str node_id: Node ID
+        :param str vpc_id: VPC ID
+        :param str vswitch_id: Switch ID
+        """
+        if hostname is not None:
+            pulumi.set(__self__, "hostname", hostname)
+        if login_password is not None:
+            pulumi.set(__self__, "login_password", login_password)
+        if node_id is not None:
+            pulumi.set(__self__, "node_id", node_id)
+        if vpc_id is not None:
+            pulumi.set(__self__, "vpc_id", vpc_id)
+        if vswitch_id is not None:
+            pulumi.set(__self__, "vswitch_id", vswitch_id)
+
+    @property
+    @pulumi.getter
+    def hostname(self) -> Optional[str]:
+        """
+        Host name
+        """
+        return pulumi.get(self, "hostname")
+
+    @property
+    @pulumi.getter(name="loginPassword")
+    def login_password(self) -> Optional[str]:
+        """
+        Login Password
+        """
+        return pulumi.get(self, "login_password")
+
+    @property
+    @pulumi.getter(name="nodeId")
+    def node_id(self) -> Optional[str]:
+        """
+        Node ID
+        """
+        return pulumi.get(self, "node_id")
+
+    @property
+    @pulumi.getter(name="vpcId")
+    def vpc_id(self) -> Optional[str]:
+        """
+        VPC ID
+        """
+        return pulumi.get(self, "vpc_id")
+
+    @property
+    @pulumi.getter(name="vswitchId")
+    def vswitch_id(self) -> Optional[str]:
+        """
+        Switch ID
+        """
+        return pulumi.get(self, "vswitch_id")
+
+
 @pulumi.output_type
 class GetSubnetsSubnetResult(dict):
     def __init__(__self__, *,