# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities
from . import outputs

__all__ = [
    'GatewaySlbList',
    'GetClustersClusterResult',
    'GetClustersClusterInstanceModelResult',
    'GetEngineNamespacesNamespaceResult',
    'GetGatewaysGatewayResult',
    'GetGatewaysGatewaySlbListResult',
    'GetNacosConfigsConfigResult',
    'GetZnodesZnodeResult',
]

@pulumi.output_type
class GatewaySlbList(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "associateId":
            suggest = "associate_id"
        elif key == "gatewaySlbMode":
            suggest = "gateway_slb_mode"
        elif key == "gatewaySlbStatus":
            suggest = "gateway_slb_status"
        elif key == "gmtCreate":
            suggest = "gmt_create"
        elif key == "slbId":
            suggest = "slb_id"
        elif key == "slbIp":
            suggest = "slb_ip"
        elif key == "slbPort":
            suggest = "slb_port"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GatewaySlbList. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GatewaySlbList.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GatewaySlbList.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 associate_id: Optional[str] = None,
                 gateway_slb_mode: Optional[str] = None,
                 gateway_slb_status: Optional[str] = None,
                 gmt_create: Optional[str] = None,
                 slb_id: Optional[str] = None,
                 slb_ip: Optional[str] = None,
                 slb_port: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param str associate_id: The associate id.
        :param str gateway_slb_mode: The Mode of the gateway slb.
        :param str gateway_slb_status: The Status of the gateway slb.
        :param str gmt_create: The creation time of the gateway slb.
        :param str slb_id: The ID of the gateway slb.
        :param str slb_ip: The ip of the gateway slb.
        :param str slb_port: The port of the gateway slb.
        :param str type: The type of the gateway slb.
        """
        if associate_id is not None:
            pulumi.set(__self__, "associate_id", associate_id)
        if gateway_slb_mode is not None:
            pulumi.set(__self__, "gateway_slb_mode", gateway_slb_mode)
        if gateway_slb_status is not None:
            pulumi.set(__self__, "gateway_slb_status", gateway_slb_status)
        if gmt_create is not None:
            pulumi.set(__self__, "gmt_create", gmt_create)
        if slb_id is not None:
            pulumi.set(__self__, "slb_id", slb_id)
        if slb_ip is not None:
            pulumi.set(__self__, "slb_ip", slb_ip)
        if slb_port is not None:
            pulumi.set(__self__, "slb_port", slb_port)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="associateId")
    def associate_id(self) -> Optional[str]:
        """
        The associate id.
        """
        return pulumi.get(self, "associate_id")

    @property
    @pulumi.getter(name="gatewaySlbMode")
    def gateway_slb_mode(self) -> Optional[str]:
        """
        The Mode of the gateway slb.
        """
        return pulumi.get(self, "gateway_slb_mode")

    @property
    @pulumi.getter(name="gatewaySlbStatus")
    def gateway_slb_status(self) -> Optional[str]:
        """
        The Status of the gateway slb.
        """
        return pulumi.get(self, "gateway_slb_status")

    @property
    @pulumi.getter(name="gmtCreate")
    def gmt_create(self) -> Optional[str]:
        """
        The creation time of the gateway slb.
        """
        return pulumi.get(self, "gmt_create")

    @property
    @pulumi.getter(name="slbId")
    def slb_id(self) -> Optional[str]:
        """
        The ID of the gateway slb.
        """
        return pulumi.get(self, "slb_id")

    @property
    @pulumi.getter(name="slbIp")
    def slb_ip(self) -> Optional[str]:
        """
        The ip of the gateway slb.
        """
        return pulumi.get(self, "slb_ip")

    @property
    @pulumi.getter(name="slbPort")
    def slb_port(self) -> Optional[str]:
        """
        The port of the gateway slb.
        """
        return pulumi.get(self, "slb_port")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The type of the gateway slb.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetClustersClusterResult(dict):
    def __init__(__self__, *,
                 acl_id: str,
                 app_version: str,
                 cluster_id: str,
                 cluster_name: str,
                 cluster_type: str,
                 cpu: int,
                 health_status: str,
                 id: str,
                 init_cost_time: int,
                 instance_count: int,
                 instance_id: str,
                 instance_models: Sequence['outputs.GetClustersClusterInstanceModelResult'],
                 internet_address: str,
                 internet_domain: str,
                 internet_port: str,
                 intranet_address: str,
                 intranet_domain: str,
                 intranet_port: str,
                 memory_capacity: int,
                 pay_info: str,
                 pub_network_flow: str,
                 status: str):
        """
        :param str acl_id: The id of acl.
        :param str app_version: The version of app.
        :param str cluster_id: ID of the MSE Cluster.
        :param str cluster_name: ID of the OOS Executions.
        :param str cluster_type: The type of MSE Cluster.
        :param int cpu: The num of cpu.
        :param str health_status: The health status of the instance.
        :param str id: ID of the MSE Cluster.
        :param int init_cost_time: Time-consuming to create.
        :param int instance_count: The count of instance.
        :param str instance_id: ID of the MSE Cluster.
        :param Sequence['GetClustersClusterInstanceModelArgs'] instance_models: The list of instance nodes.
        :param str internet_address: The address of public network.
        :param str internet_domain: The domain of public network.
        :param str internet_port: The port of public network.
        :param str intranet_address: The address of private network.
        :param str intranet_domain: The domain of private network.
        :param str intranet_port: The port of private network.
        :param int memory_capacity: The memory size.
        :param str pay_info: The type of payment.
        :param str pub_network_flow: The public network bandwidth.
        :param str status: The status of MSE Cluster. Valid: `DESTROY_FAILED`, `DESTROY_ING`, `DESTROY_SUCCESS`, `INIT_FAILED`, `INIT_ING`, `INIT_SUCCESS`, `INIT_TIME_OUT`, `RESTART_FAILED`, `RESTART_ING`, `RESTART_SUCCESS`, `SCALE_FAILED`, `SCALE_ING`, `SCALE_SUCCESS`
        """
        pulumi.set(__self__, "acl_id", acl_id)
        pulumi.set(__self__, "app_version", app_version)
        pulumi.set(__self__, "cluster_id", cluster_id)
        pulumi.set(__self__, "cluster_name", cluster_name)
        pulumi.set(__self__, "cluster_type", cluster_type)
        pulumi.set(__self__, "cpu", cpu)
        pulumi.set(__self__, "health_status", health_status)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "init_cost_time", init_cost_time)
        pulumi.set(__self__, "instance_count", instance_count)
        pulumi.set(__self__, "instance_id", instance_id)
        pulumi.set(__self__, "instance_models", instance_models)
        pulumi.set(__self__, "internet_address", internet_address)
        pulumi.set(__self__, "internet_domain", internet_domain)
        pulumi.set(__self__, "internet_port", internet_port)
        pulumi.set(__self__, "intranet_address", intranet_address)
        pulumi.set(__self__, "intranet_domain", intranet_domain)
        pulumi.set(__self__, "intranet_port", intranet_port)
        pulumi.set(__self__, "memory_capacity", memory_capacity)
        pulumi.set(__self__, "pay_info", pay_info)
        pulumi.set(__self__, "pub_network_flow", pub_network_flow)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="aclId")
    def acl_id(self) -> str:
        """
        The id of acl.
        """
        return pulumi.get(self, "acl_id")

    @property
    @pulumi.getter(name="appVersion")
    def app_version(self) -> str:
        """
        The version of app.
        """
        return pulumi.get(self, "app_version")

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> str:
        """
        ID of the MSE Cluster.
        """
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter(name="clusterName")
    def cluster_name(self) -> str:
        """
        ID of the OOS Executions.
        """
        return pulumi.get(self, "cluster_name")

    @property
    @pulumi.getter(name="clusterType")
    def cluster_type(self) -> str:
        """
        The type of MSE Cluster.
        """
        return pulumi.get(self, "cluster_type")

    @property
    @pulumi.getter
    def cpu(self) -> int:
        """
        The num of cpu.
        """
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter(name="healthStatus")
    def health_status(self) -> str:
        """
        The health status of the instance.
        """
        return pulumi.get(self, "health_status")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        ID of the MSE Cluster.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="initCostTime")
    def init_cost_time(self) -> int:
        """
        Time-consuming to create.
        """
        return pulumi.get(self, "init_cost_time")

    @property
    @pulumi.getter(name="instanceCount")
    def instance_count(self) -> int:
        """
        The count of instance.
        """
        return pulumi.get(self, "instance_count")

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> str:
        """
        ID of the MSE Cluster.
        """
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter(name="instanceModels")
    def instance_models(self) -> Sequence['outputs.GetClustersClusterInstanceModelResult']:
        """
        The list of instance nodes.
        """
        return pulumi.get(self, "instance_models")

    @property
    @pulumi.getter(name="internetAddress")
    def internet_address(self) -> str:
        """
        The address of public network.
        """
        return pulumi.get(self, "internet_address")

    @property
    @pulumi.getter(name="internetDomain")
    def internet_domain(self) -> str:
        """
        The domain of public network.
        """
        return pulumi.get(self, "internet_domain")

    @property
    @pulumi.getter(name="internetPort")
    def internet_port(self) -> str:
        """
        The port of public network.
        """
        return pulumi.get(self, "internet_port")

    @property
    @pulumi.getter(name="intranetAddress")
    def intranet_address(self) -> str:
        """
        The address of private network.
        """
        return pulumi.get(self, "intranet_address")

    @property
    @pulumi.getter(name="intranetDomain")
    def intranet_domain(self) -> str:
        """
        The domain of private network.
        """
        return pulumi.get(self, "intranet_domain")

    @property
    @pulumi.getter(name="intranetPort")
    def intranet_port(self) -> str:
        """
        The port of private network.
        """
        return pulumi.get(self, "intranet_port")

    @property
    @pulumi.getter(name="memoryCapacity")
    def memory_capacity(self) -> int:
        """
        The memory size.
        """
        return pulumi.get(self, "memory_capacity")

    @property
    @pulumi.getter(name="payInfo")
    def pay_info(self) -> str:
        """
        The type of payment.
        """
        return pulumi.get(self, "pay_info")

    @property
    @pulumi.getter(name="pubNetworkFlow")
    def pub_network_flow(self) -> str:
        """
        The public network bandwidth.
        """
        return pulumi.get(self, "pub_network_flow")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of MSE Cluster. Valid: `DESTROY_FAILED`, `DESTROY_ING`, `DESTROY_SUCCESS`, `INIT_FAILED`, `INIT_ING`, `INIT_SUCCESS`, `INIT_TIME_OUT`, `RESTART_FAILED`, `RESTART_ING`, `RESTART_SUCCESS`, `SCALE_FAILED`, `SCALE_ING`, `SCALE_SUCCESS`
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetClustersClusterInstanceModelResult(dict):
    def __init__(__self__, *,
                 health_status: str,
                 instance_type: str,
                 internet_ip: str,
                 ip: str,
                 pod_name: str,
                 role: str,
                 single_tunnel_vip: str,
                 vip: str):
        """
        :param str health_status: The health status of the instance.
        :param str instance_type: (Deprecated from version 1.232.0)
        :param str internet_ip: The public IP address.
        :param str ip: The IP address of the instance.
        :param str pod_name: The name of the pod.
        :param str role: The role.
        :param str single_tunnel_vip: The single-thread IP address.
        :param str vip: (Deprecated from version 1.232.0)
        """
        pulumi.set(__self__, "health_status", health_status)
        pulumi.set(__self__, "instance_type", instance_type)
        pulumi.set(__self__, "internet_ip", internet_ip)
        pulumi.set(__self__, "ip", ip)
        pulumi.set(__self__, "pod_name", pod_name)
        pulumi.set(__self__, "role", role)
        pulumi.set(__self__, "single_tunnel_vip", single_tunnel_vip)
        pulumi.set(__self__, "vip", vip)

    @property
    @pulumi.getter(name="healthStatus")
    def health_status(self) -> str:
        """
        The health status of the instance.
        """
        return pulumi.get(self, "health_status")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> str:
        """
        (Deprecated from version 1.232.0)
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="internetIp")
    def internet_ip(self) -> str:
        """
        The public IP address.
        """
        return pulumi.get(self, "internet_ip")

    @property
    @pulumi.getter
    def ip(self) -> str:
        """
        The IP address of the instance.
        """
        return pulumi.get(self, "ip")

    @property
    @pulumi.getter(name="podName")
    def pod_name(self) -> str:
        """
        The name of the pod.
        """
        return pulumi.get(self, "pod_name")

    @property
    @pulumi.getter
    def role(self) -> str:
        """
        The role.
        """
        return pulumi.get(self, "role")

    @property
    @pulumi.getter(name="singleTunnelVip")
    def single_tunnel_vip(self) -> str:
        """
        The single-thread IP address.
        """
        return pulumi.get(self, "single_tunnel_vip")

    @property
    @pulumi.getter
    def vip(self) -> str:
        """
        (Deprecated from version 1.232.0)
        """
        return pulumi.get(self, "vip")


@pulumi.output_type
class GetEngineNamespacesNamespaceResult(dict):
    def __init__(__self__, *,
                 config_count: int,
                 id: str,
                 namespace_desc: str,
                 namespace_id: str,
                 namespace_show_name: str,
                 quota: int,
                 service_count: str,
                 type: int):
        """
        :param int config_count: The Number of Configuration of the Namespace.
        :param str id: The ID of the Engine Namespace. It is formatted to `<instance_id>:<namespace_id>`.
        :param str namespace_desc: The description of the Namespace.
        :param str namespace_id: The id of Namespace.
        :param str namespace_show_name: The name of the Namespace.
        :param int quota: The Quota of the Namespace.
        :param str service_count: The number of active services.
        :param int type: The type of the Namespace, the value is as follows:
               - '0': Global Configuration.
               - '1': default namespace.
               - '2': Custom Namespace.
        """
        pulumi.set(__self__, "config_count", config_count)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "namespace_desc", namespace_desc)
        pulumi.set(__self__, "namespace_id", namespace_id)
        pulumi.set(__self__, "namespace_show_name", namespace_show_name)
        pulumi.set(__self__, "quota", quota)
        pulumi.set(__self__, "service_count", service_count)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="configCount")
    def config_count(self) -> int:
        """
        The Number of Configuration of the Namespace.
        """
        return pulumi.get(self, "config_count")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Engine Namespace. It is formatted to `<instance_id>:<namespace_id>`.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="namespaceDesc")
    def namespace_desc(self) -> str:
        """
        The description of the Namespace.
        """
        return pulumi.get(self, "namespace_desc")

    @property
    @pulumi.getter(name="namespaceId")
    def namespace_id(self) -> str:
        """
        The id of Namespace.
        """
        return pulumi.get(self, "namespace_id")

    @property
    @pulumi.getter(name="namespaceShowName")
    def namespace_show_name(self) -> str:
        """
        The name of the Namespace.
        """
        return pulumi.get(self, "namespace_show_name")

    @property
    @pulumi.getter
    def quota(self) -> int:
        """
        The Quota of the Namespace.
        """
        return pulumi.get(self, "quota")

    @property
    @pulumi.getter(name="serviceCount")
    def service_count(self) -> str:
        """
        The number of active services.
        """
        return pulumi.get(self, "service_count")

    @property
    @pulumi.getter
    def type(self) -> int:
        """
        The type of the Namespace, the value is as follows:
        - '0': Global Configuration.
        - '1': default namespace.
        - '2': Custom Namespace.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetGatewaysGatewayResult(dict):
    def __init__(__self__, *,
                 backup_vswitch_id: str,
                 gateway_name: str,
                 gateway_unique_id: str,
                 id: str,
                 payment_type: str,
                 replica: str,
                 slb_lists: Sequence['outputs.GetGatewaysGatewaySlbListResult'],
                 spec: str,
                 status: str,
                 vpc_id: str,
                 vswitch_id: str):
        """
        :param str backup_vswitch_id: The backup vswitch id.
        :param str gateway_name: The name of the Gateway.
        :param str gateway_unique_id: Gateway unique identification.
        :param str id: The ID of the Gateway.
        :param str payment_type: The payment type of the resource.
        :param str replica: Number of Gateway Nodes.
        :param Sequence['GetGatewaysGatewaySlbListArgs'] slb_lists: A list of gateway Slb.
        :param str spec: Gateway Node Specifications.
        :param str status: The status of the gateway.
        :param str vpc_id: The ID of the vpc.
        :param str vswitch_id: The ID of the vswitch.
        """
        pulumi.set(__self__, "backup_vswitch_id", backup_vswitch_id)
        pulumi.set(__self__, "gateway_name", gateway_name)
        pulumi.set(__self__, "gateway_unique_id", gateway_unique_id)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "payment_type", payment_type)
        pulumi.set(__self__, "replica", replica)
        pulumi.set(__self__, "slb_lists", slb_lists)
        pulumi.set(__self__, "spec", spec)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "vswitch_id", vswitch_id)

    @property
    @pulumi.getter(name="backupVswitchId")
    def backup_vswitch_id(self) -> str:
        """
        The backup vswitch id.
        """
        return pulumi.get(self, "backup_vswitch_id")

    @property
    @pulumi.getter(name="gatewayName")
    def gateway_name(self) -> str:
        """
        The name of the Gateway.
        """
        return pulumi.get(self, "gateway_name")

    @property
    @pulumi.getter(name="gatewayUniqueId")
    def gateway_unique_id(self) -> str:
        """
        Gateway unique identification.
        """
        return pulumi.get(self, "gateway_unique_id")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Gateway.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="paymentType")
    def payment_type(self) -> str:
        """
        The payment type of the resource.
        """
        return pulumi.get(self, "payment_type")

    @property
    @pulumi.getter
    def replica(self) -> str:
        """
        Number of Gateway Nodes.
        """
        return pulumi.get(self, "replica")

    @property
    @pulumi.getter(name="slbLists")
    def slb_lists(self) -> Sequence['outputs.GetGatewaysGatewaySlbListResult']:
        """
        A list of gateway Slb.
        """
        return pulumi.get(self, "slb_lists")

    @property
    @pulumi.getter
    def spec(self) -> str:
        """
        Gateway Node Specifications.
        """
        return pulumi.get(self, "spec")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the gateway.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        The ID of the vpc.
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter(name="vswitchId")
    def vswitch_id(self) -> str:
        """
        The ID of the vswitch.
        """
        return pulumi.get(self, "vswitch_id")


@pulumi.output_type
class GetGatewaysGatewaySlbListResult(dict):
    def __init__(__self__, *,
                 associate_id: str,
                 gateway_slb_mode: str,
                 gateway_slb_status: str,
                 gmt_create: str,
                 slb_id: str,
                 slb_ip: str,
                 slb_port: str,
                 type: str):
        """
        :param str associate_id: The associate id.
        :param str gateway_slb_mode: The Mode of the gateway slb.
        :param str gateway_slb_status: The Status of the gateway slb.
        :param str gmt_create: The creation time of the gateway slb.
        :param str slb_id: The ID of the gateway slb.
        :param str slb_ip: The ip of the gateway slb.
        :param str slb_port: The port of the gateway slb.
        :param str type: The type of the gateway slb.
        """
        pulumi.set(__self__, "associate_id", associate_id)
        pulumi.set(__self__, "gateway_slb_mode", gateway_slb_mode)
        pulumi.set(__self__, "gateway_slb_status", gateway_slb_status)
        pulumi.set(__self__, "gmt_create", gmt_create)
        pulumi.set(__self__, "slb_id", slb_id)
        pulumi.set(__self__, "slb_ip", slb_ip)
        pulumi.set(__self__, "slb_port", slb_port)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="associateId")
    def associate_id(self) -> str:
        """
        The associate id.
        """
        return pulumi.get(self, "associate_id")

    @property
    @pulumi.getter(name="gatewaySlbMode")
    def gateway_slb_mode(self) -> str:
        """
        The Mode of the gateway slb.
        """
        return pulumi.get(self, "gateway_slb_mode")

    @property
    @pulumi.getter(name="gatewaySlbStatus")
    def gateway_slb_status(self) -> str:
        """
        The Status of the gateway slb.
        """
        return pulumi.get(self, "gateway_slb_status")

    @property
    @pulumi.getter(name="gmtCreate")
    def gmt_create(self) -> str:
        """
        The creation time of the gateway slb.
        """
        return pulumi.get(self, "gmt_create")

    @property
    @pulumi.getter(name="slbId")
    def slb_id(self) -> str:
        """
        The ID of the gateway slb.
        """
        return pulumi.get(self, "slb_id")

    @property
    @pulumi.getter(name="slbIp")
    def slb_ip(self) -> str:
        """
        The ip of the gateway slb.
        """
        return pulumi.get(self, "slb_ip")

    @property
    @pulumi.getter(name="slbPort")
    def slb_port(self) -> str:
        """
        The port of the gateway slb.
        """
        return pulumi.get(self, "slb_port")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of the gateway slb.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetNacosConfigsConfigResult(dict):
    def __init__(__self__, *,
                 app_name: str,
                 beta_ips: str,
                 content: str,
                 data_id: str,
                 desc: str,
                 encrypted_data_key: str,
                 group: str,
                 id: str,
                 md5: str,
                 tags: str,
                 type: str):
        """
        :param str app_name: The name of the application.
        :param str beta_ips: The list of IP addresses where the beta release of the configuration is performed.
        :param str content: The content of the configuration.
        :param str data_id: The ID of the data.
        :param str desc: The description of the configuration.
        :param str encrypted_data_key: The encryption key.
        :param str group: The ID of the group.
        :param str id: The ID of the Nacos Config. It is formatted to `<instance_id>:<namespace_id>:<data_id>:<group>`.
        :param str md5: The message digest of the configuration.
        :param str tags: The tags of the configuration.
        :param str type: The format of the configuration. Supported formats include TEXT, JSON, and XML.
        """
        pulumi.set(__self__, "app_name", app_name)
        pulumi.set(__self__, "beta_ips", beta_ips)
        pulumi.set(__self__, "content", content)
        pulumi.set(__self__, "data_id", data_id)
        pulumi.set(__self__, "desc", desc)
        pulumi.set(__self__, "encrypted_data_key", encrypted_data_key)
        pulumi.set(__self__, "group", group)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "md5", md5)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="appName")
    def app_name(self) -> str:
        """
        The name of the application.
        """
        return pulumi.get(self, "app_name")

    @property
    @pulumi.getter(name="betaIps")
    def beta_ips(self) -> str:
        """
        The list of IP addresses where the beta release of the configuration is performed.
        """
        return pulumi.get(self, "beta_ips")

    @property
    @pulumi.getter
    def content(self) -> str:
        """
        The content of the configuration.
        """
        return pulumi.get(self, "content")

    @property
    @pulumi.getter(name="dataId")
    def data_id(self) -> str:
        """
        The ID of the data.
        """
        return pulumi.get(self, "data_id")

    @property
    @pulumi.getter
    def desc(self) -> str:
        """
        The description of the configuration.
        """
        return pulumi.get(self, "desc")

    @property
    @pulumi.getter(name="encryptedDataKey")
    def encrypted_data_key(self) -> str:
        """
        The encryption key.
        """
        return pulumi.get(self, "encrypted_data_key")

    @property
    @pulumi.getter
    def group(self) -> str:
        """
        The ID of the group.
        """
        return pulumi.get(self, "group")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Nacos Config. It is formatted to `<instance_id>:<namespace_id>:<data_id>:<group>`.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def md5(self) -> str:
        """
        The message digest of the configuration.
        """
        return pulumi.get(self, "md5")

    @property
    @pulumi.getter
    def tags(self) -> str:
        """
        The tags of the configuration.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The format of the configuration. Supported formats include TEXT, JSON, and XML.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetZnodesZnodeResult(dict):
    def __init__(__self__, *,
                 cluster_id: str,
                 data: str,
                 dir: bool,
                 id: str,
                 path: str,
                 znode_name: str):
        """
        :param str cluster_id: The ID of the Cluster.
        :param str data: The Node data.
        :param bool dir: Node list information, the value is as follows:
        :param str id: The ID of the Znode. The value formats as `<cluster_id>:<path>`.
        :param str path: The Node path.
        :param str znode_name: The Node name.
        """
        pulumi.set(__self__, "cluster_id", cluster_id)
        pulumi.set(__self__, "data", data)
        pulumi.set(__self__, "dir", dir)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "znode_name", znode_name)

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> str:
        """
        The ID of the Cluster.
        """
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter
    def data(self) -> str:
        """
        The Node data.
        """
        return pulumi.get(self, "data")

    @property
    @pulumi.getter
    def dir(self) -> bool:
        """
        Node list information, the value is as follows:
        """
        return pulumi.get(self, "dir")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Znode. The value formats as `<cluster_id>:<path>`.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        The Node path.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter(name="znodeName")
    def znode_name(self) -> str:
        """
        The Node name.
        """
        return pulumi.get(self, "znode_name")


