# 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 warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'ServiceMeshLoadBalancer',
    'ServiceMeshMeshConfig',
    'ServiceMeshMeshConfigAccessLog',
    'ServiceMeshMeshConfigAudit',
    'ServiceMeshMeshConfigKiali',
    'ServiceMeshMeshConfigOpa',
    'ServiceMeshMeshConfigPilot',
    'ServiceMeshMeshConfigProxy',
    'ServiceMeshMeshConfigSidecarInjector',
    'ServiceMeshNetwork',
    'GetServiceMeshesMeshResult',
    'GetServiceMeshesMeshEndpointResult',
    'GetServiceMeshesMeshLoadBalancerResult',
    'GetServiceMeshesMeshMeshConfigResult',
    'GetServiceMeshesMeshMeshConfigAccessLogResult',
    'GetServiceMeshesMeshMeshConfigAuditResult',
    'GetServiceMeshesMeshMeshConfigKialiResult',
    'GetServiceMeshesMeshMeshConfigOpaResult',
    'GetServiceMeshesMeshMeshConfigPilotResult',
    'GetServiceMeshesMeshMeshConfigPrometheusResult',
    'GetServiceMeshesMeshMeshConfigProxyResult',
    'GetServiceMeshesMeshMeshConfigSidecarInjectorResult',
    'GetServiceMeshesMeshMeshConfigSidecarInjectorInitCniConfigurationResult',
    'GetServiceMeshesMeshNetworkResult',
]

@pulumi.output_type
class ServiceMeshLoadBalancer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiServerLoadbalancerId":
            suggest = "api_server_loadbalancer_id"
        elif key == "apiServerPublicEip":
            suggest = "api_server_public_eip"
        elif key == "pilotPublicEip":
            suggest = "pilot_public_eip"
        elif key == "pilotPublicLoadbalancerId":
            suggest = "pilot_public_loadbalancer_id"

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

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

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

    def __init__(__self__, *,
                 api_server_loadbalancer_id: Optional[str] = None,
                 api_server_public_eip: Optional[bool] = None,
                 pilot_public_eip: Optional[bool] = None,
                 pilot_public_loadbalancer_id: Optional[str] = None):
        """
        :param bool api_server_public_eip: Whether to use the IP address of a public network exposed the API Server.
        :param bool pilot_public_eip: Whether to use the IP address of a public network exposure the Istio Pilot.
        """
        if api_server_loadbalancer_id is not None:
            pulumi.set(__self__, "api_server_loadbalancer_id", api_server_loadbalancer_id)
        if api_server_public_eip is not None:
            pulumi.set(__self__, "api_server_public_eip", api_server_public_eip)
        if pilot_public_eip is not None:
            pulumi.set(__self__, "pilot_public_eip", pilot_public_eip)
        if pilot_public_loadbalancer_id is not None:
            pulumi.set(__self__, "pilot_public_loadbalancer_id", pilot_public_loadbalancer_id)

    @property
    @pulumi.getter(name="apiServerLoadbalancerId")
    def api_server_loadbalancer_id(self) -> Optional[str]:
        return pulumi.get(self, "api_server_loadbalancer_id")

    @property
    @pulumi.getter(name="apiServerPublicEip")
    def api_server_public_eip(self) -> Optional[bool]:
        """
        Whether to use the IP address of a public network exposed the API Server.
        """
        return pulumi.get(self, "api_server_public_eip")

    @property
    @pulumi.getter(name="pilotPublicEip")
    def pilot_public_eip(self) -> Optional[bool]:
        """
        Whether to use the IP address of a public network exposure the Istio Pilot.
        """
        return pulumi.get(self, "pilot_public_eip")

    @property
    @pulumi.getter(name="pilotPublicLoadbalancerId")
    def pilot_public_loadbalancer_id(self) -> Optional[str]:
        return pulumi.get(self, "pilot_public_loadbalancer_id")


@pulumi.output_type
class ServiceMeshMeshConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessLog":
            suggest = "access_log"
        elif key == "customizedZipkin":
            suggest = "customized_zipkin"
        elif key == "enableLocalityLb":
            suggest = "enable_locality_lb"
        elif key == "outboundTrafficPolicy":
            suggest = "outbound_traffic_policy"
        elif key == "sidecarInjector":
            suggest = "sidecar_injector"

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

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

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

    def __init__(__self__, *,
                 access_log: Optional['outputs.ServiceMeshMeshConfigAccessLog'] = None,
                 audit: Optional['outputs.ServiceMeshMeshConfigAudit'] = None,
                 customized_zipkin: Optional[bool] = None,
                 enable_locality_lb: Optional[bool] = None,
                 kiali: Optional['outputs.ServiceMeshMeshConfigKiali'] = None,
                 opa: Optional['outputs.ServiceMeshMeshConfigOpa'] = None,
                 outbound_traffic_policy: Optional[str] = None,
                 pilot: Optional['outputs.ServiceMeshMeshConfigPilot'] = None,
                 proxy: Optional['outputs.ServiceMeshMeshConfigProxy'] = None,
                 sidecar_injector: Optional['outputs.ServiceMeshMeshConfigSidecarInjector'] = None,
                 telemetry: Optional[bool] = None,
                 tracing: Optional[bool] = None):
        """
        :param 'ServiceMeshMeshConfigAccessLogArgs' access_log: The configuration of the access logging.
        :param 'ServiceMeshMeshConfigAuditArgs' audit: The configuration of the audit. See the following `Block audit`.
        :param bool customized_zipkin: Whether or not to enable the use of a custom zipkin.
        :param bool enable_locality_lb: The enable locality lb.
        :param 'ServiceMeshMeshConfigKialiArgs' kiali: The configuration of the Kiali. See the following `Block kiali`.
        :param 'ServiceMeshMeshConfigOpaArgs' opa: The open-door policy of agent (OPA) plug-in information. See the following `Block opa`.
        :param str outbound_traffic_policy: The policy of the Out to the traffic. Valid values: `ALLOW_ANY` and `REGISTRY_ONLY`.
        :param 'ServiceMeshMeshConfigPilotArgs' pilot: The configuration of the Link trace sampling. See the following `Block pilot`.
        :param 'ServiceMeshMeshConfigProxyArgs' proxy: The configuration of the Proxy. See the following `Block proxy`.
        :param 'ServiceMeshMeshConfigSidecarInjectorArgs' sidecar_injector: The configuration of the Sidecar injector. See the following `Block sidecar_injector`.
        :param bool telemetry: Whether to enable acquisition Prometheus metrics (it is recommended that you use [Alibaba Cloud Prometheus monitoring](https://arms.console.aliyun.com/).
        :param bool tracing: Whether to enable link trace (you need to have [Alibaba Cloud link tracking service](https://tracing-analysis.console.aliyun.com/).
        """
        if access_log is not None:
            pulumi.set(__self__, "access_log", access_log)
        if audit is not None:
            pulumi.set(__self__, "audit", audit)
        if customized_zipkin is not None:
            pulumi.set(__self__, "customized_zipkin", customized_zipkin)
        if enable_locality_lb is not None:
            pulumi.set(__self__, "enable_locality_lb", enable_locality_lb)
        if kiali is not None:
            pulumi.set(__self__, "kiali", kiali)
        if opa is not None:
            pulumi.set(__self__, "opa", opa)
        if outbound_traffic_policy is not None:
            pulumi.set(__self__, "outbound_traffic_policy", outbound_traffic_policy)
        if pilot is not None:
            pulumi.set(__self__, "pilot", pilot)
        if proxy is not None:
            pulumi.set(__self__, "proxy", proxy)
        if sidecar_injector is not None:
            pulumi.set(__self__, "sidecar_injector", sidecar_injector)
        if telemetry is not None:
            pulumi.set(__self__, "telemetry", telemetry)
        if tracing is not None:
            pulumi.set(__self__, "tracing", tracing)

    @property
    @pulumi.getter(name="accessLog")
    def access_log(self) -> Optional['outputs.ServiceMeshMeshConfigAccessLog']:
        """
        The configuration of the access logging.
        """
        return pulumi.get(self, "access_log")

    @property
    @pulumi.getter
    def audit(self) -> Optional['outputs.ServiceMeshMeshConfigAudit']:
        """
        The configuration of the audit. See the following `Block audit`.
        """
        return pulumi.get(self, "audit")

    @property
    @pulumi.getter(name="customizedZipkin")
    def customized_zipkin(self) -> Optional[bool]:
        """
        Whether or not to enable the use of a custom zipkin.
        """
        return pulumi.get(self, "customized_zipkin")

    @property
    @pulumi.getter(name="enableLocalityLb")
    def enable_locality_lb(self) -> Optional[bool]:
        """
        The enable locality lb.
        """
        return pulumi.get(self, "enable_locality_lb")

    @property
    @pulumi.getter
    def kiali(self) -> Optional['outputs.ServiceMeshMeshConfigKiali']:
        """
        The configuration of the Kiali. See the following `Block kiali`.
        """
        return pulumi.get(self, "kiali")

    @property
    @pulumi.getter
    def opa(self) -> Optional['outputs.ServiceMeshMeshConfigOpa']:
        """
        The open-door policy of agent (OPA) plug-in information. See the following `Block opa`.
        """
        return pulumi.get(self, "opa")

    @property
    @pulumi.getter(name="outboundTrafficPolicy")
    def outbound_traffic_policy(self) -> Optional[str]:
        """
        The policy of the Out to the traffic. Valid values: `ALLOW_ANY` and `REGISTRY_ONLY`.
        """
        return pulumi.get(self, "outbound_traffic_policy")

    @property
    @pulumi.getter
    def pilot(self) -> Optional['outputs.ServiceMeshMeshConfigPilot']:
        """
        The configuration of the Link trace sampling. See the following `Block pilot`.
        """
        return pulumi.get(self, "pilot")

    @property
    @pulumi.getter
    def proxy(self) -> Optional['outputs.ServiceMeshMeshConfigProxy']:
        """
        The configuration of the Proxy. See the following `Block proxy`.
        """
        return pulumi.get(self, "proxy")

    @property
    @pulumi.getter(name="sidecarInjector")
    def sidecar_injector(self) -> Optional['outputs.ServiceMeshMeshConfigSidecarInjector']:
        """
        The configuration of the Sidecar injector. See the following `Block sidecar_injector`.
        """
        return pulumi.get(self, "sidecar_injector")

    @property
    @pulumi.getter
    def telemetry(self) -> Optional[bool]:
        """
        Whether to enable acquisition Prometheus metrics (it is recommended that you use [Alibaba Cloud Prometheus monitoring](https://arms.console.aliyun.com/).
        """
        return pulumi.get(self, "telemetry")

    @property
    @pulumi.getter
    def tracing(self) -> Optional[bool]:
        """
        Whether to enable link trace (you need to have [Alibaba Cloud link tracking service](https://tracing-analysis.console.aliyun.com/).
        """
        return pulumi.get(self, "tracing")


@pulumi.output_type
class ServiceMeshMeshConfigAccessLog(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None):
        """
        :param bool enabled: Whether to enable Service grid audit.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Whether to enable Service grid audit.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class ServiceMeshMeshConfigAudit(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 project: Optional[str] = None):
        """
        :param bool enabled: Whether to enable Service grid audit.
        :param str project: The Service grid audit that to the project.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if project is not None:
            pulumi.set(__self__, "project", project)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Whether to enable Service grid audit.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def project(self) -> Optional[str]:
        """
        The Service grid audit that to the project.
        """
        return pulumi.get(self, "project")


@pulumi.output_type
class ServiceMeshMeshConfigKiali(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None):
        """
        :param bool enabled: Whether to enable Service grid audit.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Whether to enable Service grid audit.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class ServiceMeshMeshConfigOpa(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "limitCpu":
            suggest = "limit_cpu"
        elif key == "limitMemory":
            suggest = "limit_memory"
        elif key == "logLevel":
            suggest = "log_level"
        elif key == "requestCpu":
            suggest = "request_cpu"
        elif key == "requestMemory":
            suggest = "request_memory"

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

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

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

    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 limit_cpu: Optional[str] = None,
                 limit_memory: Optional[str] = None,
                 log_level: Optional[str] = None,
                 request_cpu: Optional[str] = None,
                 request_memory: Optional[str] = None):
        """
        :param bool enabled: Whether to enable Service grid audit.
        :param str limit_cpu: The CPU resource  of the limitsOPA proxy container.
        :param str limit_memory: The memory resource limit of the OPA proxy container.
        :param str log_level: The log level of the OPA proxy container .
        :param str request_cpu: The CPU resource request of the OPA proxy container.
        :param str request_memory: The memory resource request of the OPA proxy container.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if limit_cpu is not None:
            pulumi.set(__self__, "limit_cpu", limit_cpu)
        if limit_memory is not None:
            pulumi.set(__self__, "limit_memory", limit_memory)
        if log_level is not None:
            pulumi.set(__self__, "log_level", log_level)
        if request_cpu is not None:
            pulumi.set(__self__, "request_cpu", request_cpu)
        if request_memory is not None:
            pulumi.set(__self__, "request_memory", request_memory)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Whether to enable Service grid audit.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="limitCpu")
    def limit_cpu(self) -> Optional[str]:
        """
        The CPU resource  of the limitsOPA proxy container.
        """
        return pulumi.get(self, "limit_cpu")

    @property
    @pulumi.getter(name="limitMemory")
    def limit_memory(self) -> Optional[str]:
        """
        The memory resource limit of the OPA proxy container.
        """
        return pulumi.get(self, "limit_memory")

    @property
    @pulumi.getter(name="logLevel")
    def log_level(self) -> Optional[str]:
        """
        The log level of the OPA proxy container .
        """
        return pulumi.get(self, "log_level")

    @property
    @pulumi.getter(name="requestCpu")
    def request_cpu(self) -> Optional[str]:
        """
        The CPU resource request of the OPA proxy container.
        """
        return pulumi.get(self, "request_cpu")

    @property
    @pulumi.getter(name="requestMemory")
    def request_memory(self) -> Optional[str]:
        """
        The memory resource request of the OPA proxy container.
        """
        return pulumi.get(self, "request_memory")


@pulumi.output_type
class ServiceMeshMeshConfigPilot(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "http10Enabled":
            suggest = "http10_enabled"
        elif key == "traceSampling":
            suggest = "trace_sampling"

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

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

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

    def __init__(__self__, *,
                 http10_enabled: Optional[bool] = None,
                 trace_sampling: Optional[float] = None):
        """
        :param bool http10_enabled: Whether to support the HTTP1.0.
        :param float trace_sampling: The  percentage of the Link trace sampling.
        """
        if http10_enabled is not None:
            pulumi.set(__self__, "http10_enabled", http10_enabled)
        if trace_sampling is not None:
            pulumi.set(__self__, "trace_sampling", trace_sampling)

    @property
    @pulumi.getter(name="http10Enabled")
    def http10_enabled(self) -> Optional[bool]:
        """
        Whether to support the HTTP1.0.
        """
        return pulumi.get(self, "http10_enabled")

    @property
    @pulumi.getter(name="traceSampling")
    def trace_sampling(self) -> Optional[float]:
        """
        The  percentage of the Link trace sampling.
        """
        return pulumi.get(self, "trace_sampling")


@pulumi.output_type
class ServiceMeshMeshConfigProxy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "limitCpu":
            suggest = "limit_cpu"
        elif key == "limitMemory":
            suggest = "limit_memory"
        elif key == "requestCpu":
            suggest = "request_cpu"
        elif key == "requestMemory":
            suggest = "request_memory"

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

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

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

    def __init__(__self__, *,
                 limit_cpu: Optional[str] = None,
                 limit_memory: Optional[str] = None,
                 request_cpu: Optional[str] = None,
                 request_memory: Optional[str] = None):
        """
        :param str limit_cpu: The CPU resource  of the limitsOPA proxy container.
        :param str limit_memory: The memory resource limit of the OPA proxy container.
        :param str request_cpu: The CPU resource request of the OPA proxy container.
        :param str request_memory: The memory resource request of the OPA proxy container.
        """
        if limit_cpu is not None:
            pulumi.set(__self__, "limit_cpu", limit_cpu)
        if limit_memory is not None:
            pulumi.set(__self__, "limit_memory", limit_memory)
        if request_cpu is not None:
            pulumi.set(__self__, "request_cpu", request_cpu)
        if request_memory is not None:
            pulumi.set(__self__, "request_memory", request_memory)

    @property
    @pulumi.getter(name="limitCpu")
    def limit_cpu(self) -> Optional[str]:
        """
        The CPU resource  of the limitsOPA proxy container.
        """
        return pulumi.get(self, "limit_cpu")

    @property
    @pulumi.getter(name="limitMemory")
    def limit_memory(self) -> Optional[str]:
        """
        The memory resource limit of the OPA proxy container.
        """
        return pulumi.get(self, "limit_memory")

    @property
    @pulumi.getter(name="requestCpu")
    def request_cpu(self) -> Optional[str]:
        """
        The CPU resource request of the OPA proxy container.
        """
        return pulumi.get(self, "request_cpu")

    @property
    @pulumi.getter(name="requestMemory")
    def request_memory(self) -> Optional[str]:
        """
        The memory resource request of the OPA proxy container.
        """
        return pulumi.get(self, "request_memory")


@pulumi.output_type
class ServiceMeshMeshConfigSidecarInjector(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoInjectionPolicyEnabled":
            suggest = "auto_injection_policy_enabled"
        elif key == "enableNamespacesByDefault":
            suggest = "enable_namespaces_by_default"
        elif key == "limitCpu":
            suggest = "limit_cpu"
        elif key == "limitMemory":
            suggest = "limit_memory"
        elif key == "requestCpu":
            suggest = "request_cpu"
        elif key == "requestMemory":
            suggest = "request_memory"

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

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

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

    def __init__(__self__, *,
                 auto_injection_policy_enabled: Optional[bool] = None,
                 enable_namespaces_by_default: Optional[bool] = None,
                 limit_cpu: Optional[str] = None,
                 limit_memory: Optional[str] = None,
                 request_cpu: Optional[str] = None,
                 request_memory: Optional[str] = None):
        """
        :param bool auto_injection_policy_enabled: Whether to enable by Pod Annotations automatic injection Sidecar.
        :param bool enable_namespaces_by_default: Whether it is the all namespaces you turn on the auto injection capabilities.
        :param str limit_cpu: The CPU resource  of the limitsOPA proxy container.
        :param str limit_memory: The memory resource limit of the OPA proxy container.
        :param str request_cpu: The CPU resource request of the OPA proxy container.
        :param str request_memory: The memory resource request of the OPA proxy container.
        """
        if auto_injection_policy_enabled is not None:
            pulumi.set(__self__, "auto_injection_policy_enabled", auto_injection_policy_enabled)
        if enable_namespaces_by_default is not None:
            pulumi.set(__self__, "enable_namespaces_by_default", enable_namespaces_by_default)
        if limit_cpu is not None:
            pulumi.set(__self__, "limit_cpu", limit_cpu)
        if limit_memory is not None:
            pulumi.set(__self__, "limit_memory", limit_memory)
        if request_cpu is not None:
            pulumi.set(__self__, "request_cpu", request_cpu)
        if request_memory is not None:
            pulumi.set(__self__, "request_memory", request_memory)

    @property
    @pulumi.getter(name="autoInjectionPolicyEnabled")
    def auto_injection_policy_enabled(self) -> Optional[bool]:
        """
        Whether to enable by Pod Annotations automatic injection Sidecar.
        """
        return pulumi.get(self, "auto_injection_policy_enabled")

    @property
    @pulumi.getter(name="enableNamespacesByDefault")
    def enable_namespaces_by_default(self) -> Optional[bool]:
        """
        Whether it is the all namespaces you turn on the auto injection capabilities.
        """
        return pulumi.get(self, "enable_namespaces_by_default")

    @property
    @pulumi.getter(name="limitCpu")
    def limit_cpu(self) -> Optional[str]:
        """
        The CPU resource  of the limitsOPA proxy container.
        """
        return pulumi.get(self, "limit_cpu")

    @property
    @pulumi.getter(name="limitMemory")
    def limit_memory(self) -> Optional[str]:
        """
        The memory resource limit of the OPA proxy container.
        """
        return pulumi.get(self, "limit_memory")

    @property
    @pulumi.getter(name="requestCpu")
    def request_cpu(self) -> Optional[str]:
        """
        The CPU resource request of the OPA proxy container.
        """
        return pulumi.get(self, "request_cpu")

    @property
    @pulumi.getter(name="requestMemory")
    def request_memory(self) -> Optional[str]:
        """
        The memory resource request of the OPA proxy container.
        """
        return pulumi.get(self, "request_memory")


@pulumi.output_type
class ServiceMeshNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vpcId":
            suggest = "vpc_id"
        elif key == "vswitcheList":
            suggest = "vswitche_list"

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

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

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

    def __init__(__self__, *,
                 vpc_id: str,
                 vswitche_list: str):
        """
        :param str vpc_id: The ID of the VPC.
        :param str vswitche_list: The list of Virtual Switch.
        """
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "vswitche_list", vswitche_list)

    @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="vswitcheList")
    def vswitche_list(self) -> str:
        """
        The list of Virtual Switch.
        """
        return pulumi.get(self, "vswitche_list")


@pulumi.output_type
class GetServiceMeshesMeshResult(dict):
    def __init__(__self__, *,
                 clusters: Sequence[str],
                 create_time: str,
                 edition: str,
                 endpoints: Sequence['outputs.GetServiceMeshesMeshEndpointResult'],
                 error_message: str,
                 id: str,
                 load_balancers: Sequence['outputs.GetServiceMeshesMeshLoadBalancerResult'],
                 mesh_configs: Sequence['outputs.GetServiceMeshesMeshMeshConfigResult'],
                 networks: Sequence['outputs.GetServiceMeshesMeshNetworkResult'],
                 service_mesh_id: str,
                 service_mesh_name: str,
                 status: str,
                 version: str):
        """
        :param Sequence[str] clusters: Cluster List.
        :param str create_time: The created time of the resource.
        :param str edition: Grid instance version type. Valid values: `Default` and `Pro`. `Default`:the standard. `Pro`:the Pro version.
        :param Sequence['GetServiceMeshesMeshEndpointArgs'] endpoints: The endpoint details.
        :param str error_message: The Cause of the Error.
        :param str id: The ID of the Service Mesh.
        :param Sequence['GetServiceMeshesMeshLoadBalancerArgs'] load_balancers: The configuration of the Load Balancer.
        :param Sequence['GetServiceMeshesMeshMeshConfigArgs'] mesh_configs: The configuration of the Service grid.
        :param Sequence['GetServiceMeshesMeshNetworkArgs'] networks: The configuration of the Service grid network.
        :param str service_mesh_id: The first ID of the resource.
        :param str service_mesh_name: The name of the resource.
        :param str status: The status of the resource.
        :param str version: The version of the resource.
        """
        pulumi.set(__self__, "clusters", clusters)
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "edition", edition)
        pulumi.set(__self__, "endpoints", endpoints)
        pulumi.set(__self__, "error_message", error_message)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "load_balancers", load_balancers)
        pulumi.set(__self__, "mesh_configs", mesh_configs)
        pulumi.set(__self__, "networks", networks)
        pulumi.set(__self__, "service_mesh_id", service_mesh_id)
        pulumi.set(__self__, "service_mesh_name", service_mesh_name)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def clusters(self) -> Sequence[str]:
        """
        Cluster List.
        """
        return pulumi.get(self, "clusters")

    @property
    @pulumi.getter(name="createTime")
    def create_time(self) -> str:
        """
        The created time of the resource.
        """
        return pulumi.get(self, "create_time")

    @property
    @pulumi.getter
    def edition(self) -> str:
        """
        Grid instance version type. Valid values: `Default` and `Pro`. `Default`:the standard. `Pro`:the Pro version.
        """
        return pulumi.get(self, "edition")

    @property
    @pulumi.getter
    def endpoints(self) -> Sequence['outputs.GetServiceMeshesMeshEndpointResult']:
        """
        The endpoint details.
        """
        return pulumi.get(self, "endpoints")

    @property
    @pulumi.getter(name="errorMessage")
    def error_message(self) -> str:
        """
        The Cause of the Error.
        """
        return pulumi.get(self, "error_message")

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

    @property
    @pulumi.getter(name="loadBalancers")
    def load_balancers(self) -> Sequence['outputs.GetServiceMeshesMeshLoadBalancerResult']:
        """
        The configuration of the Load Balancer.
        """
        return pulumi.get(self, "load_balancers")

    @property
    @pulumi.getter(name="meshConfigs")
    def mesh_configs(self) -> Sequence['outputs.GetServiceMeshesMeshMeshConfigResult']:
        """
        The configuration of the Service grid.
        """
        return pulumi.get(self, "mesh_configs")

    @property
    @pulumi.getter
    def networks(self) -> Sequence['outputs.GetServiceMeshesMeshNetworkResult']:
        """
        The configuration of the Service grid network.
        """
        return pulumi.get(self, "networks")

    @property
    @pulumi.getter(name="serviceMeshId")
    def service_mesh_id(self) -> str:
        """
        The first ID of the resource.
        """
        return pulumi.get(self, "service_mesh_id")

    @property
    @pulumi.getter(name="serviceMeshName")
    def service_mesh_name(self) -> str:
        """
        The name of the resource.
        """
        return pulumi.get(self, "service_mesh_name")

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

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


@pulumi.output_type
class GetServiceMeshesMeshEndpointResult(dict):
    def __init__(__self__, *,
                 intranet_api_server_endpoint: str,
                 intranet_pilot_endpoint: str,
                 public_api_server_endpoint: str,
                 public_pilot_endpoint: str):
        """
        :param str intranet_api_server_endpoint: The internal address of the API Server.
        :param str intranet_pilot_endpoint: The internal address of the Istio Pilot.
        :param str public_api_server_endpoint: The public address of the API Server.
        :param str public_pilot_endpoint: The public address of the Istio Pilot.
        """
        pulumi.set(__self__, "intranet_api_server_endpoint", intranet_api_server_endpoint)
        pulumi.set(__self__, "intranet_pilot_endpoint", intranet_pilot_endpoint)
        pulumi.set(__self__, "public_api_server_endpoint", public_api_server_endpoint)
        pulumi.set(__self__, "public_pilot_endpoint", public_pilot_endpoint)

    @property
    @pulumi.getter(name="intranetApiServerEndpoint")
    def intranet_api_server_endpoint(self) -> str:
        """
        The internal address of the API Server.
        """
        return pulumi.get(self, "intranet_api_server_endpoint")

    @property
    @pulumi.getter(name="intranetPilotEndpoint")
    def intranet_pilot_endpoint(self) -> str:
        """
        The internal address of the Istio Pilot.
        """
        return pulumi.get(self, "intranet_pilot_endpoint")

    @property
    @pulumi.getter(name="publicApiServerEndpoint")
    def public_api_server_endpoint(self) -> str:
        """
        The public address of the API Server.
        """
        return pulumi.get(self, "public_api_server_endpoint")

    @property
    @pulumi.getter(name="publicPilotEndpoint")
    def public_pilot_endpoint(self) -> str:
        """
        The public address of the Istio Pilot.
        """
        return pulumi.get(self, "public_pilot_endpoint")


@pulumi.output_type
class GetServiceMeshesMeshLoadBalancerResult(dict):
    def __init__(__self__, *,
                 api_server_loadbalancer_id: str,
                 api_server_public_eip: bool,
                 pilot_public_eip: bool,
                 pilot_public_loadbalancer_id: str):
        """
        :param str api_server_loadbalancer_id: The IP address of a public network exposed API Server corresponding to the Load Balance.
        :param bool api_server_public_eip: Whether to use the IP address of a public network exposed the API Server.
        :param bool pilot_public_eip: Whether to use the IP address of a public network exposure the Istio Pilot.
        :param str pilot_public_loadbalancer_id: The IP address of a public network exposure Istio Pilot corresponds to the Load Balance.
        """
        pulumi.set(__self__, "api_server_loadbalancer_id", api_server_loadbalancer_id)
        pulumi.set(__self__, "api_server_public_eip", api_server_public_eip)
        pulumi.set(__self__, "pilot_public_eip", pilot_public_eip)
        pulumi.set(__self__, "pilot_public_loadbalancer_id", pilot_public_loadbalancer_id)

    @property
    @pulumi.getter(name="apiServerLoadbalancerId")
    def api_server_loadbalancer_id(self) -> str:
        """
        The IP address of a public network exposed API Server corresponding to the Load Balance.
        """
        return pulumi.get(self, "api_server_loadbalancer_id")

    @property
    @pulumi.getter(name="apiServerPublicEip")
    def api_server_public_eip(self) -> bool:
        """
        Whether to use the IP address of a public network exposed the API Server.
        """
        return pulumi.get(self, "api_server_public_eip")

    @property
    @pulumi.getter(name="pilotPublicEip")
    def pilot_public_eip(self) -> bool:
        """
        Whether to use the IP address of a public network exposure the Istio Pilot.
        """
        return pulumi.get(self, "pilot_public_eip")

    @property
    @pulumi.getter(name="pilotPublicLoadbalancerId")
    def pilot_public_loadbalancer_id(self) -> str:
        """
        The IP address of a public network exposure Istio Pilot corresponds to the Load Balance.
        """
        return pulumi.get(self, "pilot_public_loadbalancer_id")


@pulumi.output_type
class GetServiceMeshesMeshMeshConfigResult(dict):
    def __init__(__self__, *,
                 access_logs: Sequence['outputs.GetServiceMeshesMeshMeshConfigAccessLogResult'],
                 audits: Sequence['outputs.GetServiceMeshesMeshMeshConfigAuditResult'],
                 customized_zipkin: bool,
                 enable_locality_lb: bool,
                 include_ip_ranges: str,
                 kialis: Sequence['outputs.GetServiceMeshesMeshMeshConfigKialiResult'],
                 opas: Sequence['outputs.GetServiceMeshesMeshMeshConfigOpaResult'],
                 outbound_traffic_policy: str,
                 pilots: Sequence['outputs.GetServiceMeshesMeshMeshConfigPilotResult'],
                 prometheuses: Sequence['outputs.GetServiceMeshesMeshMeshConfigPrometheusResult'],
                 proxies: Sequence['outputs.GetServiceMeshesMeshMeshConfigProxyResult'],
                 sidecar_injectors: Sequence['outputs.GetServiceMeshesMeshMeshConfigSidecarInjectorResult'],
                 telemetry: bool,
                 tracing: bool):
        """
        :param Sequence['GetServiceMeshesMeshMeshConfigAccessLogArgs'] access_logs: The configuration of the access logging.
        :param Sequence['GetServiceMeshesMeshMeshConfigAuditArgs'] audits: The configuration of the Service grid audit.
        :param bool customized_zipkin: Whether or not to enable the use of a custom zipkin.
        :param bool enable_locality_lb: Whether to enable service can access the service through the nearest node access.
        :param str include_ip_ranges: The IP ADDRESS range.
        :param Sequence['GetServiceMeshesMeshMeshConfigKialiArgs'] kialis: The configuration of the Kiali.
        :param Sequence['GetServiceMeshesMeshMeshConfigOpaArgs'] opas: The open-door policy of agent (OPA) plug-in information.
        :param str outbound_traffic_policy: The policy of the Out to the traffic. Valid values: `ALLOW_ANY` and `REGISTRY_ONLY`.
        :param Sequence['GetServiceMeshesMeshMeshConfigPilotArgs'] pilots: The configuration of the Link trace sampling.
        :param Sequence['GetServiceMeshesMeshMeshConfigPrometheusArgs'] prometheuses: the configuration of the Prometheus.
        :param Sequence['GetServiceMeshesMeshMeshConfigProxyArgs'] proxies: The configuration of the Proxy.
        :param Sequence['GetServiceMeshesMeshMeshConfigSidecarInjectorArgs'] sidecar_injectors: The configuration of the Sidecar injector.
        :param bool telemetry: Whether to enable acquisition Prometheus metrics.
        :param bool tracing: Whether to enable link trace.
        """
        pulumi.set(__self__, "access_logs", access_logs)
        pulumi.set(__self__, "audits", audits)
        pulumi.set(__self__, "customized_zipkin", customized_zipkin)
        pulumi.set(__self__, "enable_locality_lb", enable_locality_lb)
        pulumi.set(__self__, "include_ip_ranges", include_ip_ranges)
        pulumi.set(__self__, "kialis", kialis)
        pulumi.set(__self__, "opas", opas)
        pulumi.set(__self__, "outbound_traffic_policy", outbound_traffic_policy)
        pulumi.set(__self__, "pilots", pilots)
        pulumi.set(__self__, "prometheuses", prometheuses)
        pulumi.set(__self__, "proxies", proxies)
        pulumi.set(__self__, "sidecar_injectors", sidecar_injectors)
        pulumi.set(__self__, "telemetry", telemetry)
        pulumi.set(__self__, "tracing", tracing)

    @property
    @pulumi.getter(name="accessLogs")
    def access_logs(self) -> Sequence['outputs.GetServiceMeshesMeshMeshConfigAccessLogResult']:
        """
        The configuration of the access logging.
        """
        return pulumi.get(self, "access_logs")

    @property
    @pulumi.getter
    def audits(self) -> Sequence['outputs.GetServiceMeshesMeshMeshConfigAuditResult']:
        """
        The configuration of the Service grid audit.
        """
        return pulumi.get(self, "audits")

    @property
    @pulumi.getter(name="customizedZipkin")
    def customized_zipkin(self) -> bool:
        """
        Whether or not to enable the use of a custom zipkin.
        """
        return pulumi.get(self, "customized_zipkin")

    @property
    @pulumi.getter(name="enableLocalityLb")
    def enable_locality_lb(self) -> bool:
        """
        Whether to enable service can access the service through the nearest node access.
        """
        return pulumi.get(self, "enable_locality_lb")

    @property
    @pulumi.getter(name="includeIpRanges")
    def include_ip_ranges(self) -> str:
        """
        The IP ADDRESS range.
        """
        return pulumi.get(self, "include_ip_ranges")

    @property
    @pulumi.getter
    def kialis(self) -> Sequence['outputs.GetServiceMeshesMeshMeshConfigKialiResult']:
        """
        The configuration of the Kiali.
        """
        return pulumi.get(self, "kialis")

    @property
    @pulumi.getter
    def opas(self) -> Sequence['outputs.GetServiceMeshesMeshMeshConfigOpaResult']:
        """
        The open-door policy of agent (OPA) plug-in information.
        """
        return pulumi.get(self, "opas")

    @property
    @pulumi.getter(name="outboundTrafficPolicy")
    def outbound_traffic_policy(self) -> str:
        """
        The policy of the Out to the traffic. Valid values: `ALLOW_ANY` and `REGISTRY_ONLY`.
        """
        return pulumi.get(self, "outbound_traffic_policy")

    @property
    @pulumi.getter
    def pilots(self) -> Sequence['outputs.GetServiceMeshesMeshMeshConfigPilotResult']:
        """
        The configuration of the Link trace sampling.
        """
        return pulumi.get(self, "pilots")

    @property
    @pulumi.getter
    def prometheuses(self) -> Sequence['outputs.GetServiceMeshesMeshMeshConfigPrometheusResult']:
        """
        the configuration of the Prometheus.
        """
        return pulumi.get(self, "prometheuses")

    @property
    @pulumi.getter
    def proxies(self) -> Sequence['outputs.GetServiceMeshesMeshMeshConfigProxyResult']:
        """
        The configuration of the Proxy.
        """
        return pulumi.get(self, "proxies")

    @property
    @pulumi.getter(name="sidecarInjectors")
    def sidecar_injectors(self) -> Sequence['outputs.GetServiceMeshesMeshMeshConfigSidecarInjectorResult']:
        """
        The configuration of the Sidecar injector.
        """
        return pulumi.get(self, "sidecar_injectors")

    @property
    @pulumi.getter
    def telemetry(self) -> bool:
        """
        Whether to enable acquisition Prometheus metrics.
        """
        return pulumi.get(self, "telemetry")

    @property
    @pulumi.getter
    def tracing(self) -> bool:
        """
        Whether to enable link trace.
        """
        return pulumi.get(self, "tracing")


@pulumi.output_type
class GetServiceMeshesMeshMeshConfigAccessLogResult(dict):
    def __init__(__self__, *,
                 enabled: bool):
        """
        :param bool enabled: Whether to enable Service grid audit.
        """
        pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Whether to enable Service grid audit.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetServiceMeshesMeshMeshConfigAuditResult(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 project: str):
        """
        :param bool enabled: Whether to enable Service grid audit.
        :param str project: The Service grid audit that to the project.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "project", project)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Whether to enable Service grid audit.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def project(self) -> str:
        """
        The Service grid audit that to the project.
        """
        return pulumi.get(self, "project")


@pulumi.output_type
class GetServiceMeshesMeshMeshConfigKialiResult(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 url: str):
        """
        :param bool enabled: Whether to enable Service grid audit.
        :param str url: The service address of the Kiali.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Whether to enable Service grid audit.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        The service address of the Kiali.
        """
        return pulumi.get(self, "url")


@pulumi.output_type
class GetServiceMeshesMeshMeshConfigOpaResult(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 limit_cpu: str,
                 limit_memory: str,
                 log_level: str,
                 request_cpu: str,
                 request_memory: str):
        """
        :param bool enabled: Whether to enable Service grid audit.
        :param str limit_cpu: Sidecar injector Pods on the throttle.
        :param str limit_memory: The memory limit  of the Sidecar injector Pods.
        :param str log_level: The log level of the OPA proxy container .
        :param str request_cpu: The requested cpu the Sidecar injector Pods.
        :param str request_memory: The requested memory the Sidecar injector Pods.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "limit_cpu", limit_cpu)
        pulumi.set(__self__, "limit_memory", limit_memory)
        pulumi.set(__self__, "log_level", log_level)
        pulumi.set(__self__, "request_cpu", request_cpu)
        pulumi.set(__self__, "request_memory", request_memory)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Whether to enable Service grid audit.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="limitCpu")
    def limit_cpu(self) -> str:
        """
        Sidecar injector Pods on the throttle.
        """
        return pulumi.get(self, "limit_cpu")

    @property
    @pulumi.getter(name="limitMemory")
    def limit_memory(self) -> str:
        """
        The memory limit  of the Sidecar injector Pods.
        """
        return pulumi.get(self, "limit_memory")

    @property
    @pulumi.getter(name="logLevel")
    def log_level(self) -> str:
        """
        The log level of the OPA proxy container .
        """
        return pulumi.get(self, "log_level")

    @property
    @pulumi.getter(name="requestCpu")
    def request_cpu(self) -> str:
        """
        The requested cpu the Sidecar injector Pods.
        """
        return pulumi.get(self, "request_cpu")

    @property
    @pulumi.getter(name="requestMemory")
    def request_memory(self) -> str:
        """
        The requested memory the Sidecar injector Pods.
        """
        return pulumi.get(self, "request_memory")


@pulumi.output_type
class GetServiceMeshesMeshMeshConfigPilotResult(dict):
    def __init__(__self__, *,
                 http10_enabled: bool,
                 trace_sampling: float):
        """
        :param bool http10_enabled: Whether to support the HTTP1.0.
        :param float trace_sampling: The  percentage of the Link trace sampling.
        """
        pulumi.set(__self__, "http10_enabled", http10_enabled)
        pulumi.set(__self__, "trace_sampling", trace_sampling)

    @property
    @pulumi.getter(name="http10Enabled")
    def http10_enabled(self) -> bool:
        """
        Whether to support the HTTP1.0.
        """
        return pulumi.get(self, "http10_enabled")

    @property
    @pulumi.getter(name="traceSampling")
    def trace_sampling(self) -> float:
        """
        The  percentage of the Link trace sampling.
        """
        return pulumi.get(self, "trace_sampling")


@pulumi.output_type
class GetServiceMeshesMeshMeshConfigPrometheusResult(dict):
    def __init__(__self__, *,
                 external_url: str,
                 use_external: bool):
        """
        :param str external_url: The  service addresses of the Prometheus.
        :param bool use_external: Whether to enable external Prometheus.
        """
        pulumi.set(__self__, "external_url", external_url)
        pulumi.set(__self__, "use_external", use_external)

    @property
    @pulumi.getter(name="externalUrl")
    def external_url(self) -> str:
        """
        The  service addresses of the Prometheus.
        """
        return pulumi.get(self, "external_url")

    @property
    @pulumi.getter(name="useExternal")
    def use_external(self) -> bool:
        """
        Whether to enable external Prometheus.
        """
        return pulumi.get(self, "use_external")


@pulumi.output_type
class GetServiceMeshesMeshMeshConfigProxyResult(dict):
    def __init__(__self__, *,
                 cluster_domain: str,
                 limit_cpu: str,
                 limit_memory: str,
                 request_cpu: str,
                 request_memory: str):
        """
        :param str cluster_domain: The domain name of the Cluster.
        :param str limit_cpu: Sidecar injector Pods on the throttle.
        :param str limit_memory: The memory limit  of the Sidecar injector Pods.
        :param str request_cpu: The requested cpu the Sidecar injector Pods.
        :param str request_memory: The requested memory the Sidecar injector Pods.
        """
        pulumi.set(__self__, "cluster_domain", cluster_domain)
        pulumi.set(__self__, "limit_cpu", limit_cpu)
        pulumi.set(__self__, "limit_memory", limit_memory)
        pulumi.set(__self__, "request_cpu", request_cpu)
        pulumi.set(__self__, "request_memory", request_memory)

    @property
    @pulumi.getter(name="clusterDomain")
    def cluster_domain(self) -> str:
        """
        The domain name of the Cluster.
        """
        return pulumi.get(self, "cluster_domain")

    @property
    @pulumi.getter(name="limitCpu")
    def limit_cpu(self) -> str:
        """
        Sidecar injector Pods on the throttle.
        """
        return pulumi.get(self, "limit_cpu")

    @property
    @pulumi.getter(name="limitMemory")
    def limit_memory(self) -> str:
        """
        The memory limit  of the Sidecar injector Pods.
        """
        return pulumi.get(self, "limit_memory")

    @property
    @pulumi.getter(name="requestCpu")
    def request_cpu(self) -> str:
        """
        The requested cpu the Sidecar injector Pods.
        """
        return pulumi.get(self, "request_cpu")

    @property
    @pulumi.getter(name="requestMemory")
    def request_memory(self) -> str:
        """
        The requested memory the Sidecar injector Pods.
        """
        return pulumi.get(self, "request_memory")


@pulumi.output_type
class GetServiceMeshesMeshMeshConfigSidecarInjectorResult(dict):
    def __init__(__self__, *,
                 auto_injection_policy_enabled: bool,
                 enable_namespaces_by_default: bool,
                 init_cni_configurations: Sequence['outputs.GetServiceMeshesMeshMeshConfigSidecarInjectorInitCniConfigurationResult'],
                 limit_cpu: str,
                 limit_memory: str,
                 request_cpu: str,
                 request_memory: str,
                 sidecar_injector_webhook_as_yaml: str):
        """
        :param bool auto_injection_policy_enabled: Whether to enable by Pod Annotations automatic injection Sidecar.
        :param bool enable_namespaces_by_default: Whether it is the all namespaces you turn on the auto injection capabilities.
        :param Sequence['GetServiceMeshesMeshMeshConfigSidecarInjectorInitCniConfigurationArgs'] init_cni_configurations: The configuration of the CNI
        :param str limit_cpu: Sidecar injector Pods on the throttle.
        :param str limit_memory: The memory limit  of the Sidecar injector Pods.
        :param str request_cpu: The requested cpu the Sidecar injector Pods.
        :param str request_memory: The requested memory the Sidecar injector Pods.
        :param str sidecar_injector_webhook_as_yaml: Other automatic injection Sidecar configuration (in YAML format).
        """
        pulumi.set(__self__, "auto_injection_policy_enabled", auto_injection_policy_enabled)
        pulumi.set(__self__, "enable_namespaces_by_default", enable_namespaces_by_default)
        pulumi.set(__self__, "init_cni_configurations", init_cni_configurations)
        pulumi.set(__self__, "limit_cpu", limit_cpu)
        pulumi.set(__self__, "limit_memory", limit_memory)
        pulumi.set(__self__, "request_cpu", request_cpu)
        pulumi.set(__self__, "request_memory", request_memory)
        pulumi.set(__self__, "sidecar_injector_webhook_as_yaml", sidecar_injector_webhook_as_yaml)

    @property
    @pulumi.getter(name="autoInjectionPolicyEnabled")
    def auto_injection_policy_enabled(self) -> bool:
        """
        Whether to enable by Pod Annotations automatic injection Sidecar.
        """
        return pulumi.get(self, "auto_injection_policy_enabled")

    @property
    @pulumi.getter(name="enableNamespacesByDefault")
    def enable_namespaces_by_default(self) -> bool:
        """
        Whether it is the all namespaces you turn on the auto injection capabilities.
        """
        return pulumi.get(self, "enable_namespaces_by_default")

    @property
    @pulumi.getter(name="initCniConfigurations")
    def init_cni_configurations(self) -> Sequence['outputs.GetServiceMeshesMeshMeshConfigSidecarInjectorInitCniConfigurationResult']:
        """
        The configuration of the CNI
        """
        return pulumi.get(self, "init_cni_configurations")

    @property
    @pulumi.getter(name="limitCpu")
    def limit_cpu(self) -> str:
        """
        Sidecar injector Pods on the throttle.
        """
        return pulumi.get(self, "limit_cpu")

    @property
    @pulumi.getter(name="limitMemory")
    def limit_memory(self) -> str:
        """
        The memory limit  of the Sidecar injector Pods.
        """
        return pulumi.get(self, "limit_memory")

    @property
    @pulumi.getter(name="requestCpu")
    def request_cpu(self) -> str:
        """
        The requested cpu the Sidecar injector Pods.
        """
        return pulumi.get(self, "request_cpu")

    @property
    @pulumi.getter(name="requestMemory")
    def request_memory(self) -> str:
        """
        The requested memory the Sidecar injector Pods.
        """
        return pulumi.get(self, "request_memory")

    @property
    @pulumi.getter(name="sidecarInjectorWebhookAsYaml")
    def sidecar_injector_webhook_as_yaml(self) -> str:
        """
        Other automatic injection Sidecar configuration (in YAML format).
        """
        return pulumi.get(self, "sidecar_injector_webhook_as_yaml")


@pulumi.output_type
class GetServiceMeshesMeshMeshConfigSidecarInjectorInitCniConfigurationResult(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 exclude_namespaces: str):
        """
        :param bool enabled: Whether to enable Service grid audit.
        :param str exclude_namespaces: The excluded namespace of the CNI.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "exclude_namespaces", exclude_namespaces)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Whether to enable Service grid audit.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="excludeNamespaces")
    def exclude_namespaces(self) -> str:
        """
        The excluded namespace of the CNI.
        """
        return pulumi.get(self, "exclude_namespaces")


@pulumi.output_type
class GetServiceMeshesMeshNetworkResult(dict):
    def __init__(__self__, *,
                 security_group_id: str,
                 vpc_id: str,
                 vswitche_lists: Sequence[str]):
        """
        :param str security_group_id: The ID of the Security group
        :param str vpc_id: The ID of the VPC.
        :param Sequence[str] vswitche_lists: The list of Virtual Switch.
        """
        pulumi.set(__self__, "security_group_id", security_group_id)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "vswitche_lists", vswitche_lists)

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

    @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="vswitcheLists")
    def vswitche_lists(self) -> Sequence[str]:
        """
        The list of Virtual Switch.
        """
        return pulumi.get(self, "vswitche_lists")


