# 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 builtins
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__ = [
    'GatewayBackendSpec',
    'GatewayCustomLog',
    'GatewayCustomLogCustomVariable',
    'GatewayCustomLogRequestHeader',
    'GatewayCustomLogResponseHeader',
    'GatewayEvent',
    'GatewayLogSpec',
    'GatewayMonitorSpec',
    'GatewayNetworkSpec',
    'GatewayNetworkSpecSubnet',
    'GatewayResourceSpec',
    'GatewayResourceSpecNetworkType',
    'GatewayServiceAuthSpec',
    'GatewayServiceCustomDomain',
    'GatewayServiceDomain',
    'GatewayServiceDomainSpec',
    'GatewayTraceSpec',
    'GatewayTraceSpecApmTraceSpec',
    'GatewayTraceSpecTlsTraceSpec',
    'UpstreamBackendTarget',
    'UpstreamCircuitBreakingSettings',
    'UpstreamLoadBalancerSettings',
    'UpstreamLoadBalancerSettingsConsistentHashLb',
    'UpstreamLoadBalancerSettingsConsistentHashLbHttpCookie',
    'UpstreamSourceIngressSettings',
    'UpstreamSourceSourceSpec',
    'UpstreamSourceSourceSpecK8SSource',
    'UpstreamSourceSourceSpecNacosSource',
    'UpstreamSourceSourceSpecNacosSourceAuthConfig',
    'UpstreamSourceSourceSpecNacosSourceAuthConfigBasic',
    'UpstreamTlsSettings',
    'UpstreamUpstreamSpec',
    'UpstreamUpstreamSpecAiProvider',
    'UpstreamUpstreamSpecAiProviderCustomModelService',
    'UpstreamUpstreamSpecEcsInstance',
    'UpstreamUpstreamSpecK8SService',
    'UpstreamUpstreamSpecNacosService',
    'UpstreamUpstreamSpecVeFaas',
    'UpstreamVersionDetail',
    'UpstreamVersionDetailLabel',
    'GetGatewayBackendSpecResult',
    'GetGatewayCustomLogResult',
    'GetGatewayCustomLogCustomVariableResult',
    'GetGatewayCustomLogRequestHeaderResult',
    'GetGatewayCustomLogResponseHeaderResult',
    'GetGatewayEventResult',
    'GetGatewayLogSpecResult',
    'GetGatewayMonitorSpecResult',
    'GetGatewayNetworkSpecResult',
    'GetGatewayNetworkSpecSubnetResult',
    'GetGatewayResourceSpecResult',
    'GetGatewayResourceSpecNetworkTypeResult',
    'GetGatewayServiceAuthSpecResult',
    'GetGatewayServiceCustomDomainResult',
    'GetGatewayServiceDomainResult',
    'GetGatewayServiceDomainSpecResult',
    'GetGatewayTraceSpecResult',
    'GetGatewayTraceSpecApmTraceSpecResult',
    'GetGatewayTraceSpecTlsTraceSpecResult',
    'GetUpstreamBackendTargetResult',
    'GetUpstreamCircuitBreakingSettingsResult',
    'GetUpstreamLoadBalancerSettingsResult',
    'GetUpstreamLoadBalancerSettingsConsistentHashLbResult',
    'GetUpstreamLoadBalancerSettingsConsistentHashLbHttpCookieResult',
    'GetUpstreamSourceIngressSettingsResult',
    'GetUpstreamSourceSourceSpecResult',
    'GetUpstreamSourceSourceSpecK8SSourceResult',
    'GetUpstreamSourceSourceSpecNacosSourceResult',
    'GetUpstreamSourceSourceSpecNacosSourceAuthConfigResult',
    'GetUpstreamSourceSourceSpecNacosSourceAuthConfigBasicResult',
    'GetUpstreamTlsSettingsResult',
    'GetUpstreamUpstreamSpecResult',
    'GetUpstreamUpstreamSpecAiProviderResult',
    'GetUpstreamUpstreamSpecAiProviderCustomModelServiceResult',
    'GetUpstreamUpstreamSpecEcsInstanceResult',
    'GetUpstreamUpstreamSpecK8SServiceResult',
    'GetUpstreamUpstreamSpecNacosServiceResult',
    'GetUpstreamUpstreamSpecVeFaasResult',
    'GetUpstreamVersionDetailResult',
    'GetUpstreamVersionDetailLabelResult',
]

@pulumi.output_type
class GatewayBackendSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isVkeWithFlannelCniSupported":
            suggest = "is_vke_with_flannel_cni_supported"
        elif key == "vkePodCidr":
            suggest = "vke_pod_cidr"

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

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

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

    def __init__(__self__, *,
                 is_vke_with_flannel_cni_supported: Optional[builtins.bool] = None,
                 vke_pod_cidr: Optional[builtins.str] = None):
        """
        :param builtins.bool is_vke_with_flannel_cni_supported: 是否支持VKE Flannel CNI。
        :param builtins.str vke_pod_cidr: VKE Pod CIDR。
        """
        if is_vke_with_flannel_cni_supported is not None:
            pulumi.set(__self__, "is_vke_with_flannel_cni_supported", is_vke_with_flannel_cni_supported)
        if vke_pod_cidr is not None:
            pulumi.set(__self__, "vke_pod_cidr", vke_pod_cidr)

    @property
    @pulumi.getter(name="isVkeWithFlannelCniSupported")
    def is_vke_with_flannel_cni_supported(self) -> Optional[builtins.bool]:
        """
        是否支持VKE Flannel CNI。
        """
        return pulumi.get(self, "is_vke_with_flannel_cni_supported")

    @property
    @pulumi.getter(name="vkePodCidr")
    def vke_pod_cidr(self) -> Optional[builtins.str]:
        """
        VKE Pod CIDR。
        """
        return pulumi.get(self, "vke_pod_cidr")


@pulumi.output_type
class GatewayCustomLog(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customVariables":
            suggest = "custom_variables"
        elif key == "requestHeaders":
            suggest = "request_headers"
        elif key == "responseHeaders":
            suggest = "response_headers"

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

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

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

    def __init__(__self__, *,
                 custom_variables: Optional[Sequence['outputs.GatewayCustomLogCustomVariable']] = None,
                 request_headers: Optional[Sequence['outputs.GatewayCustomLogRequestHeader']] = None,
                 response_headers: Optional[Sequence['outputs.GatewayCustomLogResponseHeader']] = None):
        if custom_variables is not None:
            pulumi.set(__self__, "custom_variables", custom_variables)
        if request_headers is not None:
            pulumi.set(__self__, "request_headers", request_headers)
        if response_headers is not None:
            pulumi.set(__self__, "response_headers", response_headers)

    @property
    @pulumi.getter(name="customVariables")
    def custom_variables(self) -> Optional[Sequence['outputs.GatewayCustomLogCustomVariable']]:
        return pulumi.get(self, "custom_variables")

    @property
    @pulumi.getter(name="requestHeaders")
    def request_headers(self) -> Optional[Sequence['outputs.GatewayCustomLogRequestHeader']]:
        return pulumi.get(self, "request_headers")

    @property
    @pulumi.getter(name="responseHeaders")
    def response_headers(self) -> Optional[Sequence['outputs.GatewayCustomLogResponseHeader']]:
        return pulumi.get(self, "response_headers")


@pulumi.output_type
class GatewayCustomLogCustomVariable(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aliasesInLog":
            suggest = "aliases_in_log"

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

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

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

    def __init__(__self__, *,
                 aliases_in_log: Optional[builtins.str] = None,
                 key: Optional[builtins.str] = None):
        """
        :param builtins.str aliases_in_log: 字段别名。
        :param builtins.str key: 请求头键。
        """
        if aliases_in_log is not None:
            pulumi.set(__self__, "aliases_in_log", aliases_in_log)
        if key is not None:
            pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter(name="aliasesInLog")
    def aliases_in_log(self) -> Optional[builtins.str]:
        """
        字段别名。
        """
        return pulumi.get(self, "aliases_in_log")

    @property
    @pulumi.getter
    def key(self) -> Optional[builtins.str]:
        """
        请求头键。
        """
        return pulumi.get(self, "key")


@pulumi.output_type
class GatewayCustomLogRequestHeader(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aliasesInLog":
            suggest = "aliases_in_log"

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

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

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

    def __init__(__self__, *,
                 aliases_in_log: Optional[builtins.str] = None,
                 key: Optional[builtins.str] = None):
        """
        :param builtins.str aliases_in_log: 字段别名。
        :param builtins.str key: 请求头键。
        """
        if aliases_in_log is not None:
            pulumi.set(__self__, "aliases_in_log", aliases_in_log)
        if key is not None:
            pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter(name="aliasesInLog")
    def aliases_in_log(self) -> Optional[builtins.str]:
        """
        字段别名。
        """
        return pulumi.get(self, "aliases_in_log")

    @property
    @pulumi.getter
    def key(self) -> Optional[builtins.str]:
        """
        请求头键。
        """
        return pulumi.get(self, "key")


@pulumi.output_type
class GatewayCustomLogResponseHeader(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aliasesInLog":
            suggest = "aliases_in_log"

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

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

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

    def __init__(__self__, *,
                 aliases_in_log: Optional[builtins.str] = None,
                 key: Optional[builtins.str] = None):
        """
        :param builtins.str aliases_in_log: 字段别名。
        :param builtins.str key: 请求头键。
        """
        if aliases_in_log is not None:
            pulumi.set(__self__, "aliases_in_log", aliases_in_log)
        if key is not None:
            pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter(name="aliasesInLog")
    def aliases_in_log(self) -> Optional[builtins.str]:
        """
        字段别名。
        """
        return pulumi.get(self, "aliases_in_log")

    @property
    @pulumi.getter
    def key(self) -> Optional[builtins.str]:
        """
        请求头键。
        """
        return pulumi.get(self, "key")


@pulumi.output_type
class GatewayEvent(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "createdTime":
            suggest = "created_time"

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

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

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

    def __init__(__self__, *,
                 code: Optional[builtins.str] = None,
                 created_time: Optional[builtins.str] = None,
                 data: Optional[builtins.str] = None,
                 description: Optional[builtins.str] = None):
        """
        :param builtins.str code: 事件代码。
        :param builtins.str created_time: 事件创建时间。
        :param builtins.str data: 附带信息。
        :param builtins.str description: 事件描述。
        """
        if code is not None:
            pulumi.set(__self__, "code", code)
        if created_time is not None:
            pulumi.set(__self__, "created_time", created_time)
        if data is not None:
            pulumi.set(__self__, "data", data)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def code(self) -> Optional[builtins.str]:
        """
        事件代码。
        """
        return pulumi.get(self, "code")

    @property
    @pulumi.getter(name="createdTime")
    def created_time(self) -> Optional[builtins.str]:
        """
        事件创建时间。
        """
        return pulumi.get(self, "created_time")

    @property
    @pulumi.getter
    def data(self) -> Optional[builtins.str]:
        """
        附带信息。
        """
        return pulumi.get(self, "data")

    @property
    @pulumi.getter
    def description(self) -> Optional[builtins.str]:
        """
        事件描述。
        """
        return pulumi.get(self, "description")


@pulumi.output_type
class GatewayLogSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "projectId":
            suggest = "project_id"
        elif key == "topicId":
            suggest = "topic_id"

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

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

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

    def __init__(__self__, *,
                 enable: Optional[builtins.bool] = None,
                 project_id: Optional[builtins.str] = None,
                 topic_id: Optional[builtins.str] = None):
        """
        :param builtins.bool enable: 是否开启日志服务。
        :param builtins.str project_id: 日志项目ID。
        :param builtins.str topic_id: 日志主题ID。ProjectId 指定项目里面的日志主题。
        """
        if enable is not None:
            pulumi.set(__self__, "enable", enable)
        if project_id is not None:
            pulumi.set(__self__, "project_id", project_id)
        if topic_id is not None:
            pulumi.set(__self__, "topic_id", topic_id)

    @property
    @pulumi.getter
    def enable(self) -> Optional[builtins.bool]:
        """
        是否开启日志服务。
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> Optional[builtins.str]:
        """
        日志项目ID。
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter(name="topicId")
    def topic_id(self) -> Optional[builtins.str]:
        """
        日志主题ID。ProjectId 指定项目里面的日志主题。
        """
        return pulumi.get(self, "topic_id")


@pulumi.output_type
class GatewayMonitorSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "workspaceId":
            suggest = "workspace_id"

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

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

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

    def __init__(__self__, *,
                 enable: Optional[builtins.bool] = None,
                 workspace_id: Optional[builtins.str] = None):
        """
        :param builtins.bool enable: 托管Prometheus（VMP）服务。
        :param builtins.str workspace_id: Prometheus工作区ID。
        """
        if enable is not None:
            pulumi.set(__self__, "enable", enable)
        if workspace_id is not None:
            pulumi.set(__self__, "workspace_id", workspace_id)

    @property
    @pulumi.getter
    def enable(self) -> Optional[builtins.bool]:
        """
        托管Prometheus（VMP）服务。
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter(name="workspaceId")
    def workspace_id(self) -> Optional[builtins.str]:
        """
        Prometheus工作区ID。
        """
        return pulumi.get(self, "workspace_id")


@pulumi.output_type
class GatewayNetworkSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vpcId":
            suggest = "vpc_id"
        elif key == "vpcName":
            suggest = "vpc_name"

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

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

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

    def __init__(__self__, *,
                 subnets: Optional[Sequence['outputs.GatewayNetworkSpecSubnet']] = None,
                 vpc_id: Optional[builtins.str] = None,
                 vpc_name: Optional[builtins.str] = None):
        """
        :param builtins.str vpc_id: VPC ID。
        :param builtins.str vpc_name: VPC名称。
        """
        if subnets is not None:
            pulumi.set(__self__, "subnets", subnets)
        if vpc_id is not None:
            pulumi.set(__self__, "vpc_id", vpc_id)
        if vpc_name is not None:
            pulumi.set(__self__, "vpc_name", vpc_name)

    @property
    @pulumi.getter
    def subnets(self) -> Optional[Sequence['outputs.GatewayNetworkSpecSubnet']]:
        return pulumi.get(self, "subnets")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> Optional[builtins.str]:
        """
        VPC ID。
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter(name="vpcName")
    def vpc_name(self) -> Optional[builtins.str]:
        """
        VPC名称。
        """
        return pulumi.get(self, "vpc_name")


@pulumi.output_type
class GatewayNetworkSpecSubnet(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subnetId":
            suggest = "subnet_id"
        elif key == "subnetName":
            suggest = "subnet_name"

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

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

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

    def __init__(__self__, *,
                 az: Optional[builtins.str] = None,
                 subnet_id: Optional[builtins.str] = None,
                 subnet_name: Optional[builtins.str] = None):
        """
        :param builtins.str az: 可用区。
        :param builtins.str subnet_id: 子网ID。
        :param builtins.str subnet_name: 子网名称。
        """
        if az is not None:
            pulumi.set(__self__, "az", az)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if subnet_name is not None:
            pulumi.set(__self__, "subnet_name", subnet_name)

    @property
    @pulumi.getter
    def az(self) -> Optional[builtins.str]:
        """
        可用区。
        """
        return pulumi.get(self, "az")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[builtins.str]:
        """
        子网ID。
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="subnetName")
    def subnet_name(self) -> Optional[builtins.str]:
        """
        子网名称。
        """
        return pulumi.get(self, "subnet_name")


@pulumi.output_type
class GatewayResourceSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clbSpecCode":
            suggest = "clb_spec_code"
        elif key == "instanceSpecCode":
            suggest = "instance_spec_code"
        elif key == "networkType":
            suggest = "network_type"
        elif key == "publicNetworkBandwidth":
            suggest = "public_network_bandwidth"
        elif key == "publicNetworkBillingType":
            suggest = "public_network_billing_type"

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

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

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

    def __init__(__self__, *,
                 clb_spec_code: Optional[builtins.str] = None,
                 instance_spec_code: Optional[builtins.str] = None,
                 network_type: Optional['outputs.GatewayResourceSpecNetworkType'] = None,
                 public_network_bandwidth: Optional[builtins.int] = None,
                 public_network_billing_type: Optional[builtins.str] = None,
                 replicas: Optional[builtins.int] = None):
        """
        :param builtins.str clb_spec_code: CLB规格编码。CLB规格，取值：small*1：小型 I。small*2：小型 II。medium*1：中型 I。medium*2：中型 II。large*1：大型 I。large*2：大型 II。
        :param builtins.str instance_spec_code: 节点规格，取值：1c2g。2c4g。4c8g。8c16g。
        :param 'GatewayResourceSpecNetworkTypeArgs' network_type: 网络类型。默认值为开启公网，开启私网。
        :param builtins.int public_network_bandwidth: 公网带宽上限，该字段仅用于“按带宽上限收费”公网网络计费方式。单位为Mbps。取值限制为0~500。默认值为0。
        :param builtins.str public_network_billing_type: 公网网络计费方式，取值：traffic：按实际流量计费。bandwidth：按带宽上限计费。
        :param builtins.int replicas: 节点数量。取值限制为2~100。
        """
        if clb_spec_code is not None:
            pulumi.set(__self__, "clb_spec_code", clb_spec_code)
        if instance_spec_code is not None:
            pulumi.set(__self__, "instance_spec_code", instance_spec_code)
        if network_type is not None:
            pulumi.set(__self__, "network_type", network_type)
        if public_network_bandwidth is not None:
            pulumi.set(__self__, "public_network_bandwidth", public_network_bandwidth)
        if public_network_billing_type is not None:
            pulumi.set(__self__, "public_network_billing_type", public_network_billing_type)
        if replicas is not None:
            pulumi.set(__self__, "replicas", replicas)

    @property
    @pulumi.getter(name="clbSpecCode")
    def clb_spec_code(self) -> Optional[builtins.str]:
        """
        CLB规格编码。CLB规格，取值：small*1：小型 I。small*2：小型 II。medium*1：中型 I。medium*2：中型 II。large*1：大型 I。large*2：大型 II。
        """
        return pulumi.get(self, "clb_spec_code")

    @property
    @pulumi.getter(name="instanceSpecCode")
    def instance_spec_code(self) -> Optional[builtins.str]:
        """
        节点规格，取值：1c2g。2c4g。4c8g。8c16g。
        """
        return pulumi.get(self, "instance_spec_code")

    @property
    @pulumi.getter(name="networkType")
    def network_type(self) -> Optional['outputs.GatewayResourceSpecNetworkType']:
        """
        网络类型。默认值为开启公网，开启私网。
        """
        return pulumi.get(self, "network_type")

    @property
    @pulumi.getter(name="publicNetworkBandwidth")
    def public_network_bandwidth(self) -> Optional[builtins.int]:
        """
        公网带宽上限，该字段仅用于“按带宽上限收费”公网网络计费方式。单位为Mbps。取值限制为0~500。默认值为0。
        """
        return pulumi.get(self, "public_network_bandwidth")

    @property
    @pulumi.getter(name="publicNetworkBillingType")
    def public_network_billing_type(self) -> Optional[builtins.str]:
        """
        公网网络计费方式，取值：traffic：按实际流量计费。bandwidth：按带宽上限计费。
        """
        return pulumi.get(self, "public_network_billing_type")

    @property
    @pulumi.getter
    def replicas(self) -> Optional[builtins.int]:
        """
        节点数量。取值限制为2~100。
        """
        return pulumi.get(self, "replicas")


@pulumi.output_type
class GatewayResourceSpecNetworkType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enablePrivateNetwork":
            suggest = "enable_private_network"
        elif key == "enablePublicNetwork":
            suggest = "enable_public_network"

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

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

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

    def __init__(__self__, *,
                 enable_private_network: Optional[builtins.bool] = None,
                 enable_public_network: Optional[builtins.bool] = None):
        """
        :param builtins.bool enable_private_network: 是否启用私网。
        :param builtins.bool enable_public_network: 是否启用公网。
        """
        if enable_private_network is not None:
            pulumi.set(__self__, "enable_private_network", enable_private_network)
        if enable_public_network is not None:
            pulumi.set(__self__, "enable_public_network", enable_public_network)

    @property
    @pulumi.getter(name="enablePrivateNetwork")
    def enable_private_network(self) -> Optional[builtins.bool]:
        """
        是否启用私网。
        """
        return pulumi.get(self, "enable_private_network")

    @property
    @pulumi.getter(name="enablePublicNetwork")
    def enable_public_network(self) -> Optional[builtins.bool]:
        """
        是否启用公网。
        """
        return pulumi.get(self, "enable_public_network")


@pulumi.output_type
class GatewayServiceAuthSpec(dict):
    def __init__(__self__, *,
                 enable: Optional[builtins.bool] = None):
        """
        :param builtins.bool enable: 是否开启认证。
        """
        if enable is not None:
            pulumi.set(__self__, "enable", enable)

    @property
    @pulumi.getter
    def enable(self) -> Optional[builtins.bool]:
        """
        是否开启认证。
        """
        return pulumi.get(self, "enable")


@pulumi.output_type
class GatewayServiceCustomDomain(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "domainId":
            suggest = "domain_id"

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

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

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

    def __init__(__self__, *,
                 domain: Optional[builtins.str] = None,
                 domain_id: Optional[builtins.str] = None):
        """
        :param builtins.str domain: 自定义域名。
        :param builtins.str domain_id: 自定义域名ID。
        """
        if domain is not None:
            pulumi.set(__self__, "domain", domain)
        if domain_id is not None:
            pulumi.set(__self__, "domain_id", domain_id)

    @property
    @pulumi.getter
    def domain(self) -> Optional[builtins.str]:
        """
        自定义域名。
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter(name="domainId")
    def domain_id(self) -> Optional[builtins.str]:
        """
        自定义域名ID。
        """
        return pulumi.get(self, "domain_id")


@pulumi.output_type
class GatewayServiceDomain(dict):
    def __init__(__self__, *,
                 domain: Optional[builtins.str] = None,
                 type: Optional[builtins.str] = None):
        """
        :param builtins.str domain: 域名。
        :param builtins.str type: 域名类型。取值：public：公网。private：私网。
        """
        if domain is not None:
            pulumi.set(__self__, "domain", domain)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def domain(self) -> Optional[builtins.str]:
        """
        域名。
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter
    def type(self) -> Optional[builtins.str]:
        """
        域名类型。取值：public：公网。private：私网。
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GatewayServiceDomainSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enablePublicResolution":
            suggest = "enable_public_resolution"

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

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

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

    def __init__(__self__, *,
                 enable_public_resolution: Optional[builtins.bool] = None):
        """
        :param builtins.bool enable_public_resolution: 开启私网域名公网解析。
        """
        if enable_public_resolution is not None:
            pulumi.set(__self__, "enable_public_resolution", enable_public_resolution)

    @property
    @pulumi.getter(name="enablePublicResolution")
    def enable_public_resolution(self) -> Optional[builtins.bool]:
        """
        开启私网域名公网解析。
        """
        return pulumi.get(self, "enable_public_resolution")


@pulumi.output_type
class GatewayTraceSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apmTraceSpec":
            suggest = "apm_trace_spec"
        elif key == "tlsTraceSpec":
            suggest = "tls_trace_spec"
        elif key == "traceType":
            suggest = "trace_type"

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

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

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

    def __init__(__self__, *,
                 apm_trace_spec: Optional['outputs.GatewayTraceSpecApmTraceSpec'] = None,
                 enable: Optional[builtins.bool] = None,
                 tls_trace_spec: Optional['outputs.GatewayTraceSpecTlsTraceSpec'] = None,
                 trace_type: Optional[builtins.str] = None):
        """
        :param 'GatewayTraceSpecApmTraceSpecArgs' apm_trace_spec: 应用性能监控全链路版链路追踪配置。
        :param builtins.bool enable: 是否启用链路追踪。
        :param 'GatewayTraceSpecTlsTraceSpecArgs' tls_trace_spec: 链路追踪配置信息。
        :param builtins.str trace_type: 链路追踪类型，取值：tls：日志服务。apm：应用性能监控全链路版。
        """
        if apm_trace_spec is not None:
            pulumi.set(__self__, "apm_trace_spec", apm_trace_spec)
        if enable is not None:
            pulumi.set(__self__, "enable", enable)
        if tls_trace_spec is not None:
            pulumi.set(__self__, "tls_trace_spec", tls_trace_spec)
        if trace_type is not None:
            pulumi.set(__self__, "trace_type", trace_type)

    @property
    @pulumi.getter(name="apmTraceSpec")
    def apm_trace_spec(self) -> Optional['outputs.GatewayTraceSpecApmTraceSpec']:
        """
        应用性能监控全链路版链路追踪配置。
        """
        return pulumi.get(self, "apm_trace_spec")

    @property
    @pulumi.getter
    def enable(self) -> Optional[builtins.bool]:
        """
        是否启用链路追踪。
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter(name="tlsTraceSpec")
    def tls_trace_spec(self) -> Optional['outputs.GatewayTraceSpecTlsTraceSpec']:
        """
        链路追踪配置信息。
        """
        return pulumi.get(self, "tls_trace_spec")

    @property
    @pulumi.getter(name="traceType")
    def trace_type(self) -> Optional[builtins.str]:
        """
        链路追踪类型，取值：tls：日志服务。apm：应用性能监控全链路版。
        """
        return pulumi.get(self, "trace_type")


@pulumi.output_type
class GatewayTraceSpecApmTraceSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiKey":
            suggest = "api_key"

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

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

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

    def __init__(__self__, *,
                 api_key: Optional[builtins.str] = None):
        """
        :param builtins.str api_key: API Key。
        """
        if api_key is not None:
            pulumi.set(__self__, "api_key", api_key)

    @property
    @pulumi.getter(name="apiKey")
    def api_key(self) -> Optional[builtins.str]:
        """
        API Key。
        """
        return pulumi.get(self, "api_key")


@pulumi.output_type
class GatewayTraceSpecTlsTraceSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "iamUserAk":
            suggest = "iam_user_ak"
        elif key == "iamUserSk":
            suggest = "iam_user_sk"
        elif key == "projectId":
            suggest = "project_id"
        elif key == "traceId":
            suggest = "trace_id"

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

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

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

    def __init__(__self__, *,
                 iam_user_ak: Optional[builtins.str] = None,
                 iam_user_sk: Optional[builtins.str] = None,
                 project_id: Optional[builtins.str] = None,
                 trace_id: Optional[builtins.str] = None):
        """
        :param builtins.str iam_user_ak: Access key。
        :param builtins.str iam_user_sk: Secret key。
        :param builtins.str project_id: 日志项目ID。
        :param builtins.str trace_id: Trace ID。
        """
        if iam_user_ak is not None:
            pulumi.set(__self__, "iam_user_ak", iam_user_ak)
        if iam_user_sk is not None:
            pulumi.set(__self__, "iam_user_sk", iam_user_sk)
        if project_id is not None:
            pulumi.set(__self__, "project_id", project_id)
        if trace_id is not None:
            pulumi.set(__self__, "trace_id", trace_id)

    @property
    @pulumi.getter(name="iamUserAk")
    def iam_user_ak(self) -> Optional[builtins.str]:
        """
        Access key。
        """
        return pulumi.get(self, "iam_user_ak")

    @property
    @pulumi.getter(name="iamUserSk")
    def iam_user_sk(self) -> Optional[builtins.str]:
        """
        Secret key。
        """
        return pulumi.get(self, "iam_user_sk")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> Optional[builtins.str]:
        """
        日志项目ID。
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter(name="traceId")
    def trace_id(self) -> Optional[builtins.str]:
        """
        Trace ID。
        """
        return pulumi.get(self, "trace_id")


@pulumi.output_type
class UpstreamBackendTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "healthStatus":
            suggest = "health_status"

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

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

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

    def __init__(__self__, *,
                 health_status: Optional[builtins.str] = None,
                 ip: Optional[builtins.str] = None,
                 port: Optional[builtins.int] = None):
        """
        :param builtins.str health_status: 健康检查状态。
        :param builtins.str ip: 后端节点IP。
        :param builtins.int port: 后端节点端口。
        """
        if health_status is not None:
            pulumi.set(__self__, "health_status", health_status)
        if ip is not None:
            pulumi.set(__self__, "ip", ip)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter(name="healthStatus")
    def health_status(self) -> Optional[builtins.str]:
        """
        健康检查状态。
        """
        return pulumi.get(self, "health_status")

    @property
    @pulumi.getter
    def ip(self) -> Optional[builtins.str]:
        """
        后端节点IP。
        """
        return pulumi.get(self, "ip")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.int]:
        """
        后端节点端口。
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class UpstreamCircuitBreakingSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "baseEjectionTime":
            suggest = "base_ejection_time"
        elif key == "consecutiveErrors":
            suggest = "consecutive_errors"
        elif key == "maxEjectionPercent":
            suggest = "max_ejection_percent"
        elif key == "minHealthPercent":
            suggest = "min_health_percent"

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

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

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

    def __init__(__self__, *,
                 base_ejection_time: Optional[builtins.int] = None,
                 consecutive_errors: Optional[builtins.int] = None,
                 enable: Optional[builtins.bool] = None,
                 interval: Optional[builtins.int] = None,
                 max_ejection_percent: Optional[builtins.int] = None,
                 min_health_percent: Optional[builtins.int] = None):
        """
        :param builtins.int base_ejection_time: 最小弹出时间。单位为毫秒。取值限制为1~86400000。默认值为30秒。
        :param builtins.int consecutive_errors: 连续失败次数。取值限制为1~100。默认值为5。
        :param builtins.bool enable: 开启。
        :param builtins.int interval: 计算周期。单位为毫秒。取值限制为1~86400000。默认值为10秒。
        :param builtins.int max_ejection_percent: 最大熔断比例。取值限制为1~100。默认值为20%。
        :param builtins.int min_health_percent: 最小健康比例。取值限制为0~100。默认值为60%。
        """
        if base_ejection_time is not None:
            pulumi.set(__self__, "base_ejection_time", base_ejection_time)
        if consecutive_errors is not None:
            pulumi.set(__self__, "consecutive_errors", consecutive_errors)
        if enable is not None:
            pulumi.set(__self__, "enable", enable)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if max_ejection_percent is not None:
            pulumi.set(__self__, "max_ejection_percent", max_ejection_percent)
        if min_health_percent is not None:
            pulumi.set(__self__, "min_health_percent", min_health_percent)

    @property
    @pulumi.getter(name="baseEjectionTime")
    def base_ejection_time(self) -> Optional[builtins.int]:
        """
        最小弹出时间。单位为毫秒。取值限制为1~86400000。默认值为30秒。
        """
        return pulumi.get(self, "base_ejection_time")

    @property
    @pulumi.getter(name="consecutiveErrors")
    def consecutive_errors(self) -> Optional[builtins.int]:
        """
        连续失败次数。取值限制为1~100。默认值为5。
        """
        return pulumi.get(self, "consecutive_errors")

    @property
    @pulumi.getter
    def enable(self) -> Optional[builtins.bool]:
        """
        开启。
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter
    def interval(self) -> Optional[builtins.int]:
        """
        计算周期。单位为毫秒。取值限制为1~86400000。默认值为10秒。
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter(name="maxEjectionPercent")
    def max_ejection_percent(self) -> Optional[builtins.int]:
        """
        最大熔断比例。取值限制为1~100。默认值为20%。
        """
        return pulumi.get(self, "max_ejection_percent")

    @property
    @pulumi.getter(name="minHealthPercent")
    def min_health_percent(self) -> Optional[builtins.int]:
        """
        最小健康比例。取值限制为0~100。默认值为60%。
        """
        return pulumi.get(self, "min_health_percent")


@pulumi.output_type
class UpstreamLoadBalancerSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "consistentHashLb":
            suggest = "consistent_hash_lb"
        elif key == "lbPolicy":
            suggest = "lb_policy"
        elif key == "simpleLb":
            suggest = "simple_lb"
        elif key == "warmupDuration":
            suggest = "warmup_duration"

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

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

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

    def __init__(__self__, *,
                 consistent_hash_lb: Optional['outputs.UpstreamLoadBalancerSettingsConsistentHashLb'] = None,
                 lb_policy: Optional[builtins.str] = None,
                 simple_lb: Optional[builtins.str] = None,
                 warmup_duration: Optional[builtins.int] = None):
        """
        :param 'UpstreamLoadBalancerSettingsConsistentHashLbArgs' consistent_hash_lb: 一致性哈希负载均衡。
        :param builtins.str lb_policy: 负载均衡策略，取值：SimpleLB：简单负载均衡。ConsistentHashLB：一致性哈希负载均衡。
        :param builtins.str simple_lb: 简单负载均衡，取值：ROUND*ROBIN：轮询。LEAST*CONN：最小连接数。RANDOM：随机。
        :param builtins.int warmup_duration: 预热时间。单位为秒。
        """
        if consistent_hash_lb is not None:
            pulumi.set(__self__, "consistent_hash_lb", consistent_hash_lb)
        if lb_policy is not None:
            pulumi.set(__self__, "lb_policy", lb_policy)
        if simple_lb is not None:
            pulumi.set(__self__, "simple_lb", simple_lb)
        if warmup_duration is not None:
            pulumi.set(__self__, "warmup_duration", warmup_duration)

    @property
    @pulumi.getter(name="consistentHashLb")
    def consistent_hash_lb(self) -> Optional['outputs.UpstreamLoadBalancerSettingsConsistentHashLb']:
        """
        一致性哈希负载均衡。
        """
        return pulumi.get(self, "consistent_hash_lb")

    @property
    @pulumi.getter(name="lbPolicy")
    def lb_policy(self) -> Optional[builtins.str]:
        """
        负载均衡策略，取值：SimpleLB：简单负载均衡。ConsistentHashLB：一致性哈希负载均衡。
        """
        return pulumi.get(self, "lb_policy")

    @property
    @pulumi.getter(name="simpleLb")
    def simple_lb(self) -> Optional[builtins.str]:
        """
        简单负载均衡，取值：ROUND*ROBIN：轮询。LEAST*CONN：最小连接数。RANDOM：随机。
        """
        return pulumi.get(self, "simple_lb")

    @property
    @pulumi.getter(name="warmupDuration")
    def warmup_duration(self) -> Optional[builtins.int]:
        """
        预热时间。单位为秒。
        """
        return pulumi.get(self, "warmup_duration")


@pulumi.output_type
class UpstreamLoadBalancerSettingsConsistentHashLb(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hashKey":
            suggest = "hash_key"
        elif key == "httpCookie":
            suggest = "http_cookie"
        elif key == "httpHeaderName":
            suggest = "http_header_name"
        elif key == "httpQueryParameterName":
            suggest = "http_query_parameter_name"
        elif key == "useSourceIp":
            suggest = "use_source_ip"

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

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

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

    def __init__(__self__, *,
                 hash_key: Optional[builtins.str] = None,
                 http_cookie: Optional['outputs.UpstreamLoadBalancerSettingsConsistentHashLbHttpCookie'] = None,
                 http_header_name: Optional[builtins.str] = None,
                 http_query_parameter_name: Optional[builtins.str] = None,
                 use_source_ip: Optional[builtins.str] = None):
        """
        :param builtins.str hash_key: 一致性哈希方式，取值：UseSourceIp：基于源IP地址。HttpQueryParameterName：基于参数。HttpHeaderName：基于头。HTTPCookie：基于cookie。
        :param 'UpstreamLoadBalancerSettingsConsistentHashLbHttpCookieArgs' http_cookie: Cookie。
        :param builtins.str http_header_name: 参数。支持ASCII可打印字符，长度限制为1~256个字符。
        :param builtins.str http_query_parameter_name: 参数。支持ASCII可打印字符，长度限制为1~256个字符。
        :param builtins.str use_source_ip: 源IP地址。
        """
        if hash_key is not None:
            pulumi.set(__self__, "hash_key", hash_key)
        if http_cookie is not None:
            pulumi.set(__self__, "http_cookie", http_cookie)
        if http_header_name is not None:
            pulumi.set(__self__, "http_header_name", http_header_name)
        if http_query_parameter_name is not None:
            pulumi.set(__self__, "http_query_parameter_name", http_query_parameter_name)
        if use_source_ip is not None:
            pulumi.set(__self__, "use_source_ip", use_source_ip)

    @property
    @pulumi.getter(name="hashKey")
    def hash_key(self) -> Optional[builtins.str]:
        """
        一致性哈希方式，取值：UseSourceIp：基于源IP地址。HttpQueryParameterName：基于参数。HttpHeaderName：基于头。HTTPCookie：基于cookie。
        """
        return pulumi.get(self, "hash_key")

    @property
    @pulumi.getter(name="httpCookie")
    def http_cookie(self) -> Optional['outputs.UpstreamLoadBalancerSettingsConsistentHashLbHttpCookie']:
        """
        Cookie。
        """
        return pulumi.get(self, "http_cookie")

    @property
    @pulumi.getter(name="httpHeaderName")
    def http_header_name(self) -> Optional[builtins.str]:
        """
        参数。支持ASCII可打印字符，长度限制为1~256个字符。
        """
        return pulumi.get(self, "http_header_name")

    @property
    @pulumi.getter(name="httpQueryParameterName")
    def http_query_parameter_name(self) -> Optional[builtins.str]:
        """
        参数。支持ASCII可打印字符，长度限制为1~256个字符。
        """
        return pulumi.get(self, "http_query_parameter_name")

    @property
    @pulumi.getter(name="useSourceIp")
    def use_source_ip(self) -> Optional[builtins.str]:
        """
        源IP地址。
        """
        return pulumi.get(self, "use_source_ip")


@pulumi.output_type
class UpstreamLoadBalancerSettingsConsistentHashLbHttpCookie(dict):
    def __init__(__self__, *,
                 name: Optional[builtins.str] = None,
                 path: Optional[builtins.str] = None,
                 ttl: Optional[builtins.int] = None):
        """
        :param builtins.str name: 名称。支持ASCII可打印字符，长度限制为0~256个字符。
        :param builtins.str path: 路径。支持ASCII可打印字符，长度限制为1~256个字符。
        :param builtins.int ttl: 有效期。单位为秒。
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if ttl is not None:
            pulumi.set(__self__, "ttl", ttl)

    @property
    @pulumi.getter
    def name(self) -> Optional[builtins.str]:
        """
        名称。支持ASCII可打印字符，长度限制为0~256个字符。
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def path(self) -> Optional[builtins.str]:
        """
        路径。支持ASCII可打印字符，长度限制为1~256个字符。
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def ttl(self) -> Optional[builtins.int]:
        """
        有效期。单位为秒。
        """
        return pulumi.get(self, "ttl")


@pulumi.output_type
class UpstreamSourceIngressSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableAllIngressClasses":
            suggest = "enable_all_ingress_classes"
        elif key == "enableAllNamespaces":
            suggest = "enable_all_namespaces"
        elif key == "enableIngress":
            suggest = "enable_ingress"
        elif key == "enableIngressWithoutIngressClass":
            suggest = "enable_ingress_without_ingress_class"
        elif key == "ingressClasses":
            suggest = "ingress_classes"
        elif key == "updateStatus":
            suggest = "update_status"
        elif key == "watchNamespaces":
            suggest = "watch_namespaces"

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

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

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

    def __init__(__self__, *,
                 enable_all_ingress_classes: Optional[builtins.bool] = None,
                 enable_all_namespaces: Optional[builtins.bool] = None,
                 enable_ingress: Optional[builtins.bool] = None,
                 enable_ingress_without_ingress_class: Optional[builtins.bool] = None,
                 ingress_classes: Optional[Sequence[builtins.str]] = None,
                 update_status: Optional[builtins.bool] = None,
                 watch_namespaces: Optional[Sequence[builtins.str]] = None):
        """
        :param builtins.bool enable_all_ingress_classes: 是否启用所有Ingress类。
        :param builtins.bool enable_all_namespaces: 是否全部命名空间。
        :param builtins.bool enable_ingress: 是否开启。
        :param builtins.bool enable_ingress_without_ingress_class: 是否监听IngressClass为空的资源。
        :param Sequence[builtins.str] ingress_classes: 指定IngressClass。
        :param builtins.bool update_status: 流量入口切换。开启后，当前集群Ingress中Status的IP地址会被修改为当前网关的IP地址。
        :param Sequence[builtins.str] watch_namespaces: 指定命名空间。
        """
        if enable_all_ingress_classes is not None:
            pulumi.set(__self__, "enable_all_ingress_classes", enable_all_ingress_classes)
        if enable_all_namespaces is not None:
            pulumi.set(__self__, "enable_all_namespaces", enable_all_namespaces)
        if enable_ingress is not None:
            pulumi.set(__self__, "enable_ingress", enable_ingress)
        if enable_ingress_without_ingress_class is not None:
            pulumi.set(__self__, "enable_ingress_without_ingress_class", enable_ingress_without_ingress_class)
        if ingress_classes is not None:
            pulumi.set(__self__, "ingress_classes", ingress_classes)
        if update_status is not None:
            pulumi.set(__self__, "update_status", update_status)
        if watch_namespaces is not None:
            pulumi.set(__self__, "watch_namespaces", watch_namespaces)

    @property
    @pulumi.getter(name="enableAllIngressClasses")
    def enable_all_ingress_classes(self) -> Optional[builtins.bool]:
        """
        是否启用所有Ingress类。
        """
        return pulumi.get(self, "enable_all_ingress_classes")

    @property
    @pulumi.getter(name="enableAllNamespaces")
    def enable_all_namespaces(self) -> Optional[builtins.bool]:
        """
        是否全部命名空间。
        """
        return pulumi.get(self, "enable_all_namespaces")

    @property
    @pulumi.getter(name="enableIngress")
    def enable_ingress(self) -> Optional[builtins.bool]:
        """
        是否开启。
        """
        return pulumi.get(self, "enable_ingress")

    @property
    @pulumi.getter(name="enableIngressWithoutIngressClass")
    def enable_ingress_without_ingress_class(self) -> Optional[builtins.bool]:
        """
        是否监听IngressClass为空的资源。
        """
        return pulumi.get(self, "enable_ingress_without_ingress_class")

    @property
    @pulumi.getter(name="ingressClasses")
    def ingress_classes(self) -> Optional[Sequence[builtins.str]]:
        """
        指定IngressClass。
        """
        return pulumi.get(self, "ingress_classes")

    @property
    @pulumi.getter(name="updateStatus")
    def update_status(self) -> Optional[builtins.bool]:
        """
        流量入口切换。开启后，当前集群Ingress中Status的IP地址会被修改为当前网关的IP地址。
        """
        return pulumi.get(self, "update_status")

    @property
    @pulumi.getter(name="watchNamespaces")
    def watch_namespaces(self) -> Optional[Sequence[builtins.str]]:
        """
        指定命名空间。
        """
        return pulumi.get(self, "watch_namespaces")


@pulumi.output_type
class UpstreamSourceSourceSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "k8SSource":
            suggest = "k8_s_source"
        elif key == "nacosSource":
            suggest = "nacos_source"

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

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

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

    def __init__(__self__, *,
                 k8_s_source: Optional['outputs.UpstreamSourceSourceSpecK8SSource'] = None,
                 nacos_source: Optional['outputs.UpstreamSourceSourceSpecNacosSource'] = None):
        """
        :param 'UpstreamSourceSourceSpecK8SSourceArgs' k8_s_source: 容器集群来源。
        :param 'UpstreamSourceSourceSpecNacosSourceArgs' nacos_source: 注册中心来源。
        """
        if k8_s_source is not None:
            pulumi.set(__self__, "k8_s_source", k8_s_source)
        if nacos_source is not None:
            pulumi.set(__self__, "nacos_source", nacos_source)

    @property
    @pulumi.getter(name="k8SSource")
    def k8_s_source(self) -> Optional['outputs.UpstreamSourceSourceSpecK8SSource']:
        """
        容器集群来源。
        """
        return pulumi.get(self, "k8_s_source")

    @property
    @pulumi.getter(name="nacosSource")
    def nacos_source(self) -> Optional['outputs.UpstreamSourceSourceSpecNacosSource']:
        """
        注册中心来源。
        """
        return pulumi.get(self, "nacos_source")


@pulumi.output_type
class UpstreamSourceSourceSpecK8SSource(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterId":
            suggest = "cluster_id"
        elif key == "clusterType":
            suggest = "cluster_type"

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

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

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

    def __init__(__self__, *,
                 cluster_id: Optional[builtins.str] = None,
                 cluster_type: Optional[builtins.str] = None):
        """
        :param builtins.str cluster_id: 集群ID。
        :param builtins.str cluster_type: 集群类型。
        """
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)
        if cluster_type is not None:
            pulumi.set(__self__, "cluster_type", cluster_type)

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> Optional[builtins.str]:
        """
        集群ID。
        """
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter(name="clusterType")
    def cluster_type(self) -> Optional[builtins.str]:
        """
        集群类型。
        """
        return pulumi.get(self, "cluster_type")


@pulumi.output_type
class UpstreamSourceSourceSpecNacosSource(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authConfig":
            suggest = "auth_config"
        elif key == "nacosId":
            suggest = "nacos_id"
        elif key == "nacosName":
            suggest = "nacos_name"

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

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

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

    def __init__(__self__, *,
                 auth_config: Optional['outputs.UpstreamSourceSourceSpecNacosSourceAuthConfig'] = None,
                 nacos_id: Optional[builtins.str] = None,
                 nacos_name: Optional[builtins.str] = None):
        """
        :param 'UpstreamSourceSourceSpecNacosSourceAuthConfigArgs' auth_config: 认证配置。
        :param builtins.str nacos_id: Nacos ID。
        :param builtins.str nacos_name: Nacos名称。
        """
        if auth_config is not None:
            pulumi.set(__self__, "auth_config", auth_config)
        if nacos_id is not None:
            pulumi.set(__self__, "nacos_id", nacos_id)
        if nacos_name is not None:
            pulumi.set(__self__, "nacos_name", nacos_name)

    @property
    @pulumi.getter(name="authConfig")
    def auth_config(self) -> Optional['outputs.UpstreamSourceSourceSpecNacosSourceAuthConfig']:
        """
        认证配置。
        """
        return pulumi.get(self, "auth_config")

    @property
    @pulumi.getter(name="nacosId")
    def nacos_id(self) -> Optional[builtins.str]:
        """
        Nacos ID。
        """
        return pulumi.get(self, "nacos_id")

    @property
    @pulumi.getter(name="nacosName")
    def nacos_name(self) -> Optional[builtins.str]:
        """
        Nacos名称。
        """
        return pulumi.get(self, "nacos_name")


@pulumi.output_type
class UpstreamSourceSourceSpecNacosSourceAuthConfig(dict):
    def __init__(__self__, *,
                 basic: Optional['outputs.UpstreamSourceSourceSpecNacosSourceAuthConfigBasic'] = None):
        """
        :param 'UpstreamSourceSourceSpecNacosSourceAuthConfigBasicArgs' basic: Basic认证。
        """
        if basic is not None:
            pulumi.set(__self__, "basic", basic)

    @property
    @pulumi.getter
    def basic(self) -> Optional['outputs.UpstreamSourceSourceSpecNacosSourceAuthConfigBasic']:
        """
        Basic认证。
        """
        return pulumi.get(self, "basic")


@pulumi.output_type
class UpstreamSourceSourceSpecNacosSourceAuthConfigBasic(dict):
    def __init__(__self__, *,
                 password: Optional[builtins.str] = None,
                 username: Optional[builtins.str] = None):
        """
        :param builtins.str password: 密码。
        :param builtins.str username: 用户名。
        """
        if password is not None:
            pulumi.set(__self__, "password", password)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def password(self) -> Optional[builtins.str]:
        """
        密码。
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> Optional[builtins.str]:
        """
        用户名。
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class UpstreamTlsSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "tlsMode":
            suggest = "tls_mode"

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

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

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

    def __init__(__self__, *,
                 sni: Optional[builtins.str] = None,
                 tls_mode: Optional[builtins.str] = None):
        """
        :param builtins.str sni: SNI。留空时会将访问网关的域名透传到upstream。
        :param builtins.str tls_mode: TLS模式，取值：DISABLE：关闭TLS。SIMPLE：单向TLS。
        """
        if sni is not None:
            pulumi.set(__self__, "sni", sni)
        if tls_mode is not None:
            pulumi.set(__self__, "tls_mode", tls_mode)

    @property
    @pulumi.getter
    def sni(self) -> Optional[builtins.str]:
        """
        SNI。留空时会将访问网关的域名透传到upstream。
        """
        return pulumi.get(self, "sni")

    @property
    @pulumi.getter(name="tlsMode")
    def tls_mode(self) -> Optional[builtins.str]:
        """
        TLS模式，取值：DISABLE：关闭TLS。SIMPLE：单向TLS。
        """
        return pulumi.get(self, "tls_mode")


@pulumi.output_type
class UpstreamUpstreamSpec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aiProvider":
            suggest = "ai_provider"
        elif key == "ecsInstances":
            suggest = "ecs_instances"
        elif key == "k8SService":
            suggest = "k8_s_service"
        elif key == "nacosService":
            suggest = "nacos_service"
        elif key == "veFaas":
            suggest = "ve_faas"

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

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

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

    def __init__(__self__, *,
                 ai_provider: Optional['outputs.UpstreamUpstreamSpecAiProvider'] = None,
                 ecs_instances: Optional[Sequence['outputs.UpstreamUpstreamSpecEcsInstance']] = None,
                 k8_s_service: Optional['outputs.UpstreamUpstreamSpecK8SService'] = None,
                 nacos_service: Optional['outputs.UpstreamUpstreamSpecNacosService'] = None,
                 ve_faas: Optional['outputs.UpstreamUpstreamSpecVeFaas'] = None):
        """
        :param 'UpstreamUpstreamSpecAiProviderArgs' ai_provider: AI模型代理。
        :param 'UpstreamUpstreamSpecK8SServiceArgs' k8_s_service: 容器服务。
        :param 'UpstreamUpstreamSpecNacosServiceArgs' nacos_service: 注册中心。
        :param 'UpstreamUpstreamSpecVeFaasArgs' ve_faas: 函数服务。
        """
        if ai_provider is not None:
            pulumi.set(__self__, "ai_provider", ai_provider)
        if ecs_instances is not None:
            pulumi.set(__self__, "ecs_instances", ecs_instances)
        if k8_s_service is not None:
            pulumi.set(__self__, "k8_s_service", k8_s_service)
        if nacos_service is not None:
            pulumi.set(__self__, "nacos_service", nacos_service)
        if ve_faas is not None:
            pulumi.set(__self__, "ve_faas", ve_faas)

    @property
    @pulumi.getter(name="aiProvider")
    def ai_provider(self) -> Optional['outputs.UpstreamUpstreamSpecAiProvider']:
        """
        AI模型代理。
        """
        return pulumi.get(self, "ai_provider")

    @property
    @pulumi.getter(name="ecsInstances")
    def ecs_instances(self) -> Optional[Sequence['outputs.UpstreamUpstreamSpecEcsInstance']]:
        return pulumi.get(self, "ecs_instances")

    @property
    @pulumi.getter(name="k8SService")
    def k8_s_service(self) -> Optional['outputs.UpstreamUpstreamSpecK8SService']:
        """
        容器服务。
        """
        return pulumi.get(self, "k8_s_service")

    @property
    @pulumi.getter(name="nacosService")
    def nacos_service(self) -> Optional['outputs.UpstreamUpstreamSpecNacosService']:
        """
        注册中心。
        """
        return pulumi.get(self, "nacos_service")

    @property
    @pulumi.getter(name="veFaas")
    def ve_faas(self) -> Optional['outputs.UpstreamUpstreamSpecVeFaas']:
        """
        函数服务。
        """
        return pulumi.get(self, "ve_faas")


@pulumi.output_type
class UpstreamUpstreamSpecAiProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "baseUrl":
            suggest = "base_url"
        elif key == "customModelService":
            suggest = "custom_model_service"

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

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

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

    def __init__(__self__, *,
                 base_url: Optional[builtins.str] = None,
                 custom_model_service: Optional['outputs.UpstreamUpstreamSpecAiProviderCustomModelService'] = None,
                 name: Optional[builtins.str] = None,
                 token: Optional[builtins.str] = None):
        """
        :param builtins.str base_url: 模型地址。
        :param 'UpstreamUpstreamSpecAiProviderCustomModelServiceArgs' custom_model_service: 火山自部署模型服务。
        :param builtins.str name: 模型服务商名称。
        :param builtins.str token: 模型API key。
        """
        if base_url is not None:
            pulumi.set(__self__, "base_url", base_url)
        if custom_model_service is not None:
            pulumi.set(__self__, "custom_model_service", custom_model_service)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if token is not None:
            pulumi.set(__self__, "token", token)

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> Optional[builtins.str]:
        """
        模型地址。
        """
        return pulumi.get(self, "base_url")

    @property
    @pulumi.getter(name="customModelService")
    def custom_model_service(self) -> Optional['outputs.UpstreamUpstreamSpecAiProviderCustomModelService']:
        """
        火山自部署模型服务。
        """
        return pulumi.get(self, "custom_model_service")

    @property
    @pulumi.getter
    def name(self) -> Optional[builtins.str]:
        """
        模型服务商名称。
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def token(self) -> Optional[builtins.str]:
        """
        模型API key。
        """
        return pulumi.get(self, "token")


@pulumi.output_type
class UpstreamUpstreamSpecAiProviderCustomModelService(dict):
    def __init__(__self__, *,
                 name: Optional[builtins.str] = None,
                 namespace: Optional[builtins.str] = None,
                 port: Optional[builtins.int] = None):
        """
        :param builtins.str name: 模型服务名称。
        :param builtins.str namespace: 命名空间。
        :param builtins.int port: 端口。
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if namespace is not None:
            pulumi.set(__self__, "namespace", namespace)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def name(self) -> Optional[builtins.str]:
        """
        模型服务名称。
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def namespace(self) -> Optional[builtins.str]:
        """
        命名空间。
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.int]:
        """
        端口。
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class UpstreamUpstreamSpecEcsInstance(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ecsId":
            suggest = "ecs_id"

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

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

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

    def __init__(__self__, *,
                 ecs_id: Optional[builtins.str] = None,
                 ip: Optional[builtins.str] = None,
                 port: Optional[builtins.int] = None):
        """
        :param builtins.str ecs_id: 云服务器ID。
        :param builtins.str ip: IP地址。
        :param builtins.int port: 端口。
        """
        if ecs_id is not None:
            pulumi.set(__self__, "ecs_id", ecs_id)
        if ip is not None:
            pulumi.set(__self__, "ip", ip)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter(name="ecsId")
    def ecs_id(self) -> Optional[builtins.str]:
        """
        云服务器ID。
        """
        return pulumi.get(self, "ecs_id")

    @property
    @pulumi.getter
    def ip(self) -> Optional[builtins.str]:
        """
        IP地址。
        """
        return pulumi.get(self, "ip")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.int]:
        """
        端口。
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class UpstreamUpstreamSpecK8SService(dict):
    def __init__(__self__, *,
                 name: Optional[builtins.str] = None,
                 namespace: Optional[builtins.str] = None,
                 port: Optional[builtins.int] = None):
        """
        :param builtins.str name: 容器服务名称。长度限制为2~63个字符。
        :param builtins.str namespace: 命名空间。长度限制为2~63个字符。
        :param builtins.int port: 端口。
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if namespace is not None:
            pulumi.set(__self__, "namespace", namespace)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def name(self) -> Optional[builtins.str]:
        """
        容器服务名称。长度限制为2~63个字符。
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def namespace(self) -> Optional[builtins.str]:
        """
        命名空间。长度限制为2~63个字符。
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.int]:
        """
        端口。
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class UpstreamUpstreamSpecNacosService(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "namespaceId":
            suggest = "namespace_id"
        elif key == "upstreamSourceId":
            suggest = "upstream_source_id"

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

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

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

    def __init__(__self__, *,
                 group: Optional[builtins.str] = None,
                 namespace: Optional[builtins.str] = None,
                 namespace_id: Optional[builtins.str] = None,
                 service: Optional[builtins.str] = None,
                 upstream_source_id: Optional[builtins.str] = None):
        """
        :param builtins.str group: 分组。
        :param builtins.str namespace: 命名空间。
        :param builtins.str namespace_id: 命名空间ID。
        :param builtins.str service: 服务。
        :param builtins.str upstream_source_id: Upstream来源ID。
        """
        if group is not None:
            pulumi.set(__self__, "group", group)
        if namespace is not None:
            pulumi.set(__self__, "namespace", namespace)
        if namespace_id is not None:
            pulumi.set(__self__, "namespace_id", namespace_id)
        if service is not None:
            pulumi.set(__self__, "service", service)
        if upstream_source_id is not None:
            pulumi.set(__self__, "upstream_source_id", upstream_source_id)

    @property
    @pulumi.getter
    def group(self) -> Optional[builtins.str]:
        """
        分组。
        """
        return pulumi.get(self, "group")

    @property
    @pulumi.getter
    def namespace(self) -> Optional[builtins.str]:
        """
        命名空间。
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter(name="namespaceId")
    def namespace_id(self) -> Optional[builtins.str]:
        """
        命名空间ID。
        """
        return pulumi.get(self, "namespace_id")

    @property
    @pulumi.getter
    def service(self) -> Optional[builtins.str]:
        """
        服务。
        """
        return pulumi.get(self, "service")

    @property
    @pulumi.getter(name="upstreamSourceId")
    def upstream_source_id(self) -> Optional[builtins.str]:
        """
        Upstream来源ID。
        """
        return pulumi.get(self, "upstream_source_id")


@pulumi.output_type
class UpstreamUpstreamSpecVeFaas(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "functionId":
            suggest = "function_id"

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

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

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

    def __init__(__self__, *,
                 function_id: Optional[builtins.str] = None):
        """
        :param builtins.str function_id: 函数ID。
        """
        if function_id is not None:
            pulumi.set(__self__, "function_id", function_id)

    @property
    @pulumi.getter(name="functionId")
    def function_id(self) -> Optional[builtins.str]:
        """
        函数ID。
        """
        return pulumi.get(self, "function_id")


@pulumi.output_type
class UpstreamVersionDetail(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "updateTime":
            suggest = "update_time"

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

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

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

    def __init__(__self__, *,
                 labels: Optional[Sequence['outputs.UpstreamVersionDetailLabel']] = None,
                 name: Optional[builtins.str] = None,
                 update_time: Optional[builtins.str] = None):
        """
        :param builtins.str name: 版本名称。支持大小写字母、数字和中划线（-），长度限制为2~63个字符。不能以中划线（-）开头。
        :param builtins.str update_time: 更新时间。
        """
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if update_time is not None:
            pulumi.set(__self__, "update_time", update_time)

    @property
    @pulumi.getter
    def labels(self) -> Optional[Sequence['outputs.UpstreamVersionDetailLabel']]:
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def name(self) -> Optional[builtins.str]:
        """
        版本名称。支持大小写字母、数字和中划线（-），长度限制为2~63个字符。不能以中划线（-）开头。
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="updateTime")
    def update_time(self) -> Optional[builtins.str]:
        """
        更新时间。
        """
        return pulumi.get(self, "update_time")


@pulumi.output_type
class UpstreamVersionDetailLabel(dict):
    def __init__(__self__, *,
                 key: Optional[builtins.str] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str key: 键。
        :param builtins.str value: 值。
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[builtins.str]:
        """
        键。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        """
        值。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetGatewayBackendSpecResult(dict):
    def __init__(__self__, *,
                 is_vke_with_flannel_cni_supported: builtins.bool,
                 vke_pod_cidr: builtins.str):
        """
        :param builtins.bool is_vke_with_flannel_cni_supported: 是否支持VKE Flannel CNI。
        :param builtins.str vke_pod_cidr: VKE Pod CIDR。
        """
        pulumi.set(__self__, "is_vke_with_flannel_cni_supported", is_vke_with_flannel_cni_supported)
        pulumi.set(__self__, "vke_pod_cidr", vke_pod_cidr)

    @property
    @pulumi.getter(name="isVkeWithFlannelCniSupported")
    def is_vke_with_flannel_cni_supported(self) -> builtins.bool:
        """
        是否支持VKE Flannel CNI。
        """
        return pulumi.get(self, "is_vke_with_flannel_cni_supported")

    @property
    @pulumi.getter(name="vkePodCidr")
    def vke_pod_cidr(self) -> builtins.str:
        """
        VKE Pod CIDR。
        """
        return pulumi.get(self, "vke_pod_cidr")


@pulumi.output_type
class GetGatewayCustomLogResult(dict):
    def __init__(__self__, *,
                 custom_variables: Sequence['outputs.GetGatewayCustomLogCustomVariableResult'],
                 request_headers: Sequence['outputs.GetGatewayCustomLogRequestHeaderResult'],
                 response_headers: Sequence['outputs.GetGatewayCustomLogResponseHeaderResult']):
        """
        :param Sequence['GetGatewayCustomLogCustomVariableArgs'] custom_variables: 自定义变量信息。
        :param Sequence['GetGatewayCustomLogRequestHeaderArgs'] request_headers: 请求头信息。
        :param Sequence['GetGatewayCustomLogResponseHeaderArgs'] response_headers: 响应头信息。
        """
        pulumi.set(__self__, "custom_variables", custom_variables)
        pulumi.set(__self__, "request_headers", request_headers)
        pulumi.set(__self__, "response_headers", response_headers)

    @property
    @pulumi.getter(name="customVariables")
    def custom_variables(self) -> Sequence['outputs.GetGatewayCustomLogCustomVariableResult']:
        """
        自定义变量信息。
        """
        return pulumi.get(self, "custom_variables")

    @property
    @pulumi.getter(name="requestHeaders")
    def request_headers(self) -> Sequence['outputs.GetGatewayCustomLogRequestHeaderResult']:
        """
        请求头信息。
        """
        return pulumi.get(self, "request_headers")

    @property
    @pulumi.getter(name="responseHeaders")
    def response_headers(self) -> Sequence['outputs.GetGatewayCustomLogResponseHeaderResult']:
        """
        响应头信息。
        """
        return pulumi.get(self, "response_headers")


@pulumi.output_type
class GetGatewayCustomLogCustomVariableResult(dict):
    def __init__(__self__, *,
                 aliases_in_log: builtins.str,
                 key: builtins.str):
        """
        :param builtins.str aliases_in_log: 字段别名。
        :param builtins.str key: 请求头键。
        """
        pulumi.set(__self__, "aliases_in_log", aliases_in_log)
        pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter(name="aliasesInLog")
    def aliases_in_log(self) -> builtins.str:
        """
        字段别名。
        """
        return pulumi.get(self, "aliases_in_log")

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        请求头键。
        """
        return pulumi.get(self, "key")


@pulumi.output_type
class GetGatewayCustomLogRequestHeaderResult(dict):
    def __init__(__self__, *,
                 aliases_in_log: builtins.str,
                 key: builtins.str):
        """
        :param builtins.str aliases_in_log: 字段别名。
        :param builtins.str key: 请求头键。
        """
        pulumi.set(__self__, "aliases_in_log", aliases_in_log)
        pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter(name="aliasesInLog")
    def aliases_in_log(self) -> builtins.str:
        """
        字段别名。
        """
        return pulumi.get(self, "aliases_in_log")

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        请求头键。
        """
        return pulumi.get(self, "key")


@pulumi.output_type
class GetGatewayCustomLogResponseHeaderResult(dict):
    def __init__(__self__, *,
                 aliases_in_log: builtins.str,
                 key: builtins.str):
        """
        :param builtins.str aliases_in_log: 字段别名。
        :param builtins.str key: 请求头键。
        """
        pulumi.set(__self__, "aliases_in_log", aliases_in_log)
        pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter(name="aliasesInLog")
    def aliases_in_log(self) -> builtins.str:
        """
        字段别名。
        """
        return pulumi.get(self, "aliases_in_log")

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        请求头键。
        """
        return pulumi.get(self, "key")


@pulumi.output_type
class GetGatewayEventResult(dict):
    def __init__(__self__, *,
                 code: builtins.str,
                 created_time: builtins.str,
                 data: builtins.str,
                 description: builtins.str):
        """
        :param builtins.str code: 事件代码。
        :param builtins.str created_time: 事件创建时间。
        :param builtins.str data: 附带信息。
        :param builtins.str description: 事件描述。
        """
        pulumi.set(__self__, "code", code)
        pulumi.set(__self__, "created_time", created_time)
        pulumi.set(__self__, "data", data)
        pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def code(self) -> builtins.str:
        """
        事件代码。
        """
        return pulumi.get(self, "code")

    @property
    @pulumi.getter(name="createdTime")
    def created_time(self) -> builtins.str:
        """
        事件创建时间。
        """
        return pulumi.get(self, "created_time")

    @property
    @pulumi.getter
    def data(self) -> builtins.str:
        """
        附带信息。
        """
        return pulumi.get(self, "data")

    @property
    @pulumi.getter
    def description(self) -> builtins.str:
        """
        事件描述。
        """
        return pulumi.get(self, "description")


@pulumi.output_type
class GetGatewayLogSpecResult(dict):
    def __init__(__self__, *,
                 enable: builtins.bool,
                 project_id: builtins.str,
                 topic_id: builtins.str):
        """
        :param builtins.bool enable: 是否开启日志服务。
        :param builtins.str project_id: 日志项目ID。
        :param builtins.str topic_id: 日志主题ID。ProjectId 指定项目里面的日志主题。
        """
        pulumi.set(__self__, "enable", enable)
        pulumi.set(__self__, "project_id", project_id)
        pulumi.set(__self__, "topic_id", topic_id)

    @property
    @pulumi.getter
    def enable(self) -> builtins.bool:
        """
        是否开启日志服务。
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> builtins.str:
        """
        日志项目ID。
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter(name="topicId")
    def topic_id(self) -> builtins.str:
        """
        日志主题ID。ProjectId 指定项目里面的日志主题。
        """
        return pulumi.get(self, "topic_id")


@pulumi.output_type
class GetGatewayMonitorSpecResult(dict):
    def __init__(__self__, *,
                 enable: builtins.bool,
                 workspace_id: builtins.str):
        """
        :param builtins.bool enable: 托管Prometheus（VMP）服务。
        :param builtins.str workspace_id: Prometheus工作区ID。
        """
        pulumi.set(__self__, "enable", enable)
        pulumi.set(__self__, "workspace_id", workspace_id)

    @property
    @pulumi.getter
    def enable(self) -> builtins.bool:
        """
        托管Prometheus（VMP）服务。
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter(name="workspaceId")
    def workspace_id(self) -> builtins.str:
        """
        Prometheus工作区ID。
        """
        return pulumi.get(self, "workspace_id")


@pulumi.output_type
class GetGatewayNetworkSpecResult(dict):
    def __init__(__self__, *,
                 subnets: Sequence['outputs.GetGatewayNetworkSpecSubnetResult'],
                 vpc_id: builtins.str,
                 vpc_name: builtins.str):
        """
        :param Sequence['GetGatewayNetworkSpecSubnetArgs'] subnets: 子网配置信息列表。
        :param builtins.str vpc_id: VPC ID。
        :param builtins.str vpc_name: VPC名称。
        """
        pulumi.set(__self__, "subnets", subnets)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "vpc_name", vpc_name)

    @property
    @pulumi.getter
    def subnets(self) -> Sequence['outputs.GetGatewayNetworkSpecSubnetResult']:
        """
        子网配置信息列表。
        """
        return pulumi.get(self, "subnets")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> builtins.str:
        """
        VPC ID。
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter(name="vpcName")
    def vpc_name(self) -> builtins.str:
        """
        VPC名称。
        """
        return pulumi.get(self, "vpc_name")


@pulumi.output_type
class GetGatewayNetworkSpecSubnetResult(dict):
    def __init__(__self__, *,
                 az: builtins.str,
                 subnet_id: builtins.str,
                 subnet_name: builtins.str):
        """
        :param builtins.str az: 可用区。
        :param builtins.str subnet_id: 子网ID。
        :param builtins.str subnet_name: 子网名称。
        """
        pulumi.set(__self__, "az", az)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "subnet_name", subnet_name)

    @property
    @pulumi.getter
    def az(self) -> builtins.str:
        """
        可用区。
        """
        return pulumi.get(self, "az")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        """
        子网ID。
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="subnetName")
    def subnet_name(self) -> builtins.str:
        """
        子网名称。
        """
        return pulumi.get(self, "subnet_name")


@pulumi.output_type
class GetGatewayResourceSpecResult(dict):
    def __init__(__self__, *,
                 clb_spec_code: builtins.str,
                 instance_spec_code: builtins.str,
                 network_type: 'outputs.GetGatewayResourceSpecNetworkTypeResult',
                 public_network_bandwidth: builtins.int,
                 public_network_billing_type: builtins.str,
                 replicas: builtins.int):
        """
        :param builtins.str clb_spec_code: CLB规格编码。CLB规格，取值：small*1：小型 I。small*2：小型 II。medium*1：中型 I。medium*2：中型 II。large*1：大型 I。large*2：大型 II。
        :param builtins.str instance_spec_code: 节点规格，取值：1c2g。2c4g。4c8g。8c16g。
        :param 'GetGatewayResourceSpecNetworkTypeArgs' network_type: 网络类型。默认值为开启公网，开启私网。
        :param builtins.int public_network_bandwidth: 公网带宽上限，该字段仅用于“按带宽上限收费”公网网络计费方式。单位为Mbps。取值限制为0~500。默认值为0。
        :param builtins.str public_network_billing_type: 公网网络计费方式，取值：traffic：按实际流量计费。bandwidth：按带宽上限计费。
        :param builtins.int replicas: 节点数量。取值限制为2~100。
        """
        pulumi.set(__self__, "clb_spec_code", clb_spec_code)
        pulumi.set(__self__, "instance_spec_code", instance_spec_code)
        pulumi.set(__self__, "network_type", network_type)
        pulumi.set(__self__, "public_network_bandwidth", public_network_bandwidth)
        pulumi.set(__self__, "public_network_billing_type", public_network_billing_type)
        pulumi.set(__self__, "replicas", replicas)

    @property
    @pulumi.getter(name="clbSpecCode")
    def clb_spec_code(self) -> builtins.str:
        """
        CLB规格编码。CLB规格，取值：small*1：小型 I。small*2：小型 II。medium*1：中型 I。medium*2：中型 II。large*1：大型 I。large*2：大型 II。
        """
        return pulumi.get(self, "clb_spec_code")

    @property
    @pulumi.getter(name="instanceSpecCode")
    def instance_spec_code(self) -> builtins.str:
        """
        节点规格，取值：1c2g。2c4g。4c8g。8c16g。
        """
        return pulumi.get(self, "instance_spec_code")

    @property
    @pulumi.getter(name="networkType")
    def network_type(self) -> 'outputs.GetGatewayResourceSpecNetworkTypeResult':
        """
        网络类型。默认值为开启公网，开启私网。
        """
        return pulumi.get(self, "network_type")

    @property
    @pulumi.getter(name="publicNetworkBandwidth")
    def public_network_bandwidth(self) -> builtins.int:
        """
        公网带宽上限，该字段仅用于“按带宽上限收费”公网网络计费方式。单位为Mbps。取值限制为0~500。默认值为0。
        """
        return pulumi.get(self, "public_network_bandwidth")

    @property
    @pulumi.getter(name="publicNetworkBillingType")
    def public_network_billing_type(self) -> builtins.str:
        """
        公网网络计费方式，取值：traffic：按实际流量计费。bandwidth：按带宽上限计费。
        """
        return pulumi.get(self, "public_network_billing_type")

    @property
    @pulumi.getter
    def replicas(self) -> builtins.int:
        """
        节点数量。取值限制为2~100。
        """
        return pulumi.get(self, "replicas")


@pulumi.output_type
class GetGatewayResourceSpecNetworkTypeResult(dict):
    def __init__(__self__, *,
                 enable_private_network: builtins.bool,
                 enable_public_network: builtins.bool):
        """
        :param builtins.bool enable_private_network: 是否启用私网。
        :param builtins.bool enable_public_network: 是否启用公网。
        """
        pulumi.set(__self__, "enable_private_network", enable_private_network)
        pulumi.set(__self__, "enable_public_network", enable_public_network)

    @property
    @pulumi.getter(name="enablePrivateNetwork")
    def enable_private_network(self) -> builtins.bool:
        """
        是否启用私网。
        """
        return pulumi.get(self, "enable_private_network")

    @property
    @pulumi.getter(name="enablePublicNetwork")
    def enable_public_network(self) -> builtins.bool:
        """
        是否启用公网。
        """
        return pulumi.get(self, "enable_public_network")


@pulumi.output_type
class GetGatewayServiceAuthSpecResult(dict):
    def __init__(__self__, *,
                 enable: builtins.bool):
        """
        :param builtins.bool enable: 是否开启认证。
        """
        pulumi.set(__self__, "enable", enable)

    @property
    @pulumi.getter
    def enable(self) -> builtins.bool:
        """
        是否开启认证。
        """
        return pulumi.get(self, "enable")


@pulumi.output_type
class GetGatewayServiceCustomDomainResult(dict):
    def __init__(__self__, *,
                 domain: builtins.str,
                 domain_id: builtins.str):
        """
        :param builtins.str domain: 自定义域名。
        :param builtins.str domain_id: 自定义域名ID。
        """
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "domain_id", domain_id)

    @property
    @pulumi.getter
    def domain(self) -> builtins.str:
        """
        自定义域名。
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter(name="domainId")
    def domain_id(self) -> builtins.str:
        """
        自定义域名ID。
        """
        return pulumi.get(self, "domain_id")


@pulumi.output_type
class GetGatewayServiceDomainResult(dict):
    def __init__(__self__, *,
                 domain: builtins.str,
                 type: builtins.str):
        """
        :param builtins.str domain: 域名。
        :param builtins.str type: 域名类型。取值：public：公网。private：私网。
        """
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def domain(self) -> builtins.str:
        """
        域名。
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter
    def type(self) -> builtins.str:
        """
        域名类型。取值：public：公网。private：私网。
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetGatewayServiceDomainSpecResult(dict):
    def __init__(__self__, *,
                 enable_public_resolution: builtins.bool):
        """
        :param builtins.bool enable_public_resolution: 开启私网域名公网解析。
        """
        pulumi.set(__self__, "enable_public_resolution", enable_public_resolution)

    @property
    @pulumi.getter(name="enablePublicResolution")
    def enable_public_resolution(self) -> builtins.bool:
        """
        开启私网域名公网解析。
        """
        return pulumi.get(self, "enable_public_resolution")


@pulumi.output_type
class GetGatewayTraceSpecResult(dict):
    def __init__(__self__, *,
                 apm_trace_spec: 'outputs.GetGatewayTraceSpecApmTraceSpecResult',
                 enable: builtins.bool,
                 tls_trace_spec: 'outputs.GetGatewayTraceSpecTlsTraceSpecResult',
                 trace_type: builtins.str):
        """
        :param 'GetGatewayTraceSpecApmTraceSpecArgs' apm_trace_spec: 应用性能监控全链路版链路追踪配置。
        :param builtins.bool enable: 是否启用链路追踪。
        :param 'GetGatewayTraceSpecTlsTraceSpecArgs' tls_trace_spec: 链路追踪配置信息。
        :param builtins.str trace_type: 链路追踪类型，取值：tls：日志服务。apm：应用性能监控全链路版。
        """
        pulumi.set(__self__, "apm_trace_spec", apm_trace_spec)
        pulumi.set(__self__, "enable", enable)
        pulumi.set(__self__, "tls_trace_spec", tls_trace_spec)
        pulumi.set(__self__, "trace_type", trace_type)

    @property
    @pulumi.getter(name="apmTraceSpec")
    def apm_trace_spec(self) -> 'outputs.GetGatewayTraceSpecApmTraceSpecResult':
        """
        应用性能监控全链路版链路追踪配置。
        """
        return pulumi.get(self, "apm_trace_spec")

    @property
    @pulumi.getter
    def enable(self) -> builtins.bool:
        """
        是否启用链路追踪。
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter(name="tlsTraceSpec")
    def tls_trace_spec(self) -> 'outputs.GetGatewayTraceSpecTlsTraceSpecResult':
        """
        链路追踪配置信息。
        """
        return pulumi.get(self, "tls_trace_spec")

    @property
    @pulumi.getter(name="traceType")
    def trace_type(self) -> builtins.str:
        """
        链路追踪类型，取值：tls：日志服务。apm：应用性能监控全链路版。
        """
        return pulumi.get(self, "trace_type")


@pulumi.output_type
class GetGatewayTraceSpecApmTraceSpecResult(dict):
    def __init__(__self__, *,
                 api_key: builtins.str):
        """
        :param builtins.str api_key: API Key。
        """
        pulumi.set(__self__, "api_key", api_key)

    @property
    @pulumi.getter(name="apiKey")
    def api_key(self) -> builtins.str:
        """
        API Key。
        """
        return pulumi.get(self, "api_key")


@pulumi.output_type
class GetGatewayTraceSpecTlsTraceSpecResult(dict):
    def __init__(__self__, *,
                 iam_user_ak: builtins.str,
                 iam_user_sk: builtins.str,
                 project_id: builtins.str,
                 trace_id: builtins.str):
        """
        :param builtins.str iam_user_ak: Access key。
        :param builtins.str iam_user_sk: Secret key。
        :param builtins.str project_id: 日志项目ID。
        :param builtins.str trace_id: Trace ID。
        """
        pulumi.set(__self__, "iam_user_ak", iam_user_ak)
        pulumi.set(__self__, "iam_user_sk", iam_user_sk)
        pulumi.set(__self__, "project_id", project_id)
        pulumi.set(__self__, "trace_id", trace_id)

    @property
    @pulumi.getter(name="iamUserAk")
    def iam_user_ak(self) -> builtins.str:
        """
        Access key。
        """
        return pulumi.get(self, "iam_user_ak")

    @property
    @pulumi.getter(name="iamUserSk")
    def iam_user_sk(self) -> builtins.str:
        """
        Secret key。
        """
        return pulumi.get(self, "iam_user_sk")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> builtins.str:
        """
        日志项目ID。
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter(name="traceId")
    def trace_id(self) -> builtins.str:
        """
        Trace ID。
        """
        return pulumi.get(self, "trace_id")


@pulumi.output_type
class GetUpstreamBackendTargetResult(dict):
    def __init__(__self__, *,
                 health_status: builtins.str,
                 ip: builtins.str,
                 port: builtins.int):
        """
        :param builtins.str health_status: 健康检查状态。
        :param builtins.str ip: 后端节点IP。
        :param builtins.int port: 后端节点端口。
        """
        pulumi.set(__self__, "health_status", health_status)
        pulumi.set(__self__, "ip", ip)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter(name="healthStatus")
    def health_status(self) -> builtins.str:
        """
        健康检查状态。
        """
        return pulumi.get(self, "health_status")

    @property
    @pulumi.getter
    def ip(self) -> builtins.str:
        """
        后端节点IP。
        """
        return pulumi.get(self, "ip")

    @property
    @pulumi.getter
    def port(self) -> builtins.int:
        """
        后端节点端口。
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class GetUpstreamCircuitBreakingSettingsResult(dict):
    def __init__(__self__, *,
                 base_ejection_time: builtins.int,
                 consecutive_errors: builtins.int,
                 enable: builtins.bool,
                 interval: builtins.int,
                 max_ejection_percent: builtins.int,
                 min_health_percent: builtins.int):
        """
        :param builtins.int base_ejection_time: 最小弹出时间。单位为毫秒。取值限制为1~86400000。默认值为30秒。
        :param builtins.int consecutive_errors: 连续失败次数。取值限制为1~100。默认值为5。
        :param builtins.bool enable: 开启。
        :param builtins.int interval: 计算周期。单位为毫秒。取值限制为1~86400000。默认值为10秒。
        :param builtins.int max_ejection_percent: 最大熔断比例。取值限制为1~100。默认值为20%。
        :param builtins.int min_health_percent: 最小健康比例。取值限制为0~100。默认值为60%。
        """
        pulumi.set(__self__, "base_ejection_time", base_ejection_time)
        pulumi.set(__self__, "consecutive_errors", consecutive_errors)
        pulumi.set(__self__, "enable", enable)
        pulumi.set(__self__, "interval", interval)
        pulumi.set(__self__, "max_ejection_percent", max_ejection_percent)
        pulumi.set(__self__, "min_health_percent", min_health_percent)

    @property
    @pulumi.getter(name="baseEjectionTime")
    def base_ejection_time(self) -> builtins.int:
        """
        最小弹出时间。单位为毫秒。取值限制为1~86400000。默认值为30秒。
        """
        return pulumi.get(self, "base_ejection_time")

    @property
    @pulumi.getter(name="consecutiveErrors")
    def consecutive_errors(self) -> builtins.int:
        """
        连续失败次数。取值限制为1~100。默认值为5。
        """
        return pulumi.get(self, "consecutive_errors")

    @property
    @pulumi.getter
    def enable(self) -> builtins.bool:
        """
        开启。
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter
    def interval(self) -> builtins.int:
        """
        计算周期。单位为毫秒。取值限制为1~86400000。默认值为10秒。
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter(name="maxEjectionPercent")
    def max_ejection_percent(self) -> builtins.int:
        """
        最大熔断比例。取值限制为1~100。默认值为20%。
        """
        return pulumi.get(self, "max_ejection_percent")

    @property
    @pulumi.getter(name="minHealthPercent")
    def min_health_percent(self) -> builtins.int:
        """
        最小健康比例。取值限制为0~100。默认值为60%。
        """
        return pulumi.get(self, "min_health_percent")


@pulumi.output_type
class GetUpstreamLoadBalancerSettingsResult(dict):
    def __init__(__self__, *,
                 consistent_hash_lb: 'outputs.GetUpstreamLoadBalancerSettingsConsistentHashLbResult',
                 lb_policy: builtins.str,
                 simple_lb: builtins.str,
                 warmup_duration: builtins.int):
        """
        :param 'GetUpstreamLoadBalancerSettingsConsistentHashLbArgs' consistent_hash_lb: 一致性哈希负载均衡。
        :param builtins.str lb_policy: 负载均衡策略，取值：SimpleLB：简单负载均衡。ConsistentHashLB：一致性哈希负载均衡。
        :param builtins.str simple_lb: 简单负载均衡，取值：ROUND*ROBIN：轮询。LEAST*CONN：最小连接数。RANDOM：随机。
        :param builtins.int warmup_duration: 预热时间。单位为秒。
        """
        pulumi.set(__self__, "consistent_hash_lb", consistent_hash_lb)
        pulumi.set(__self__, "lb_policy", lb_policy)
        pulumi.set(__self__, "simple_lb", simple_lb)
        pulumi.set(__self__, "warmup_duration", warmup_duration)

    @property
    @pulumi.getter(name="consistentHashLb")
    def consistent_hash_lb(self) -> 'outputs.GetUpstreamLoadBalancerSettingsConsistentHashLbResult':
        """
        一致性哈希负载均衡。
        """
        return pulumi.get(self, "consistent_hash_lb")

    @property
    @pulumi.getter(name="lbPolicy")
    def lb_policy(self) -> builtins.str:
        """
        负载均衡策略，取值：SimpleLB：简单负载均衡。ConsistentHashLB：一致性哈希负载均衡。
        """
        return pulumi.get(self, "lb_policy")

    @property
    @pulumi.getter(name="simpleLb")
    def simple_lb(self) -> builtins.str:
        """
        简单负载均衡，取值：ROUND*ROBIN：轮询。LEAST*CONN：最小连接数。RANDOM：随机。
        """
        return pulumi.get(self, "simple_lb")

    @property
    @pulumi.getter(name="warmupDuration")
    def warmup_duration(self) -> builtins.int:
        """
        预热时间。单位为秒。
        """
        return pulumi.get(self, "warmup_duration")


@pulumi.output_type
class GetUpstreamLoadBalancerSettingsConsistentHashLbResult(dict):
    def __init__(__self__, *,
                 hash_key: builtins.str,
                 http_cookie: 'outputs.GetUpstreamLoadBalancerSettingsConsistentHashLbHttpCookieResult',
                 http_header_name: builtins.str,
                 http_query_parameter_name: builtins.str,
                 use_source_ip: builtins.str):
        """
        :param builtins.str hash_key: 一致性哈希方式，取值：UseSourceIp：基于源IP地址。HttpQueryParameterName：基于参数。HttpHeaderName：基于头。HTTPCookie：基于cookie。
        :param 'GetUpstreamLoadBalancerSettingsConsistentHashLbHttpCookieArgs' http_cookie: Cookie。
        :param builtins.str http_header_name: 参数。支持ASCII可打印字符，长度限制为1~256个字符。
        :param builtins.str http_query_parameter_name: 参数。支持ASCII可打印字符，长度限制为1~256个字符。
        :param builtins.str use_source_ip: 源IP地址。
        """
        pulumi.set(__self__, "hash_key", hash_key)
        pulumi.set(__self__, "http_cookie", http_cookie)
        pulumi.set(__self__, "http_header_name", http_header_name)
        pulumi.set(__self__, "http_query_parameter_name", http_query_parameter_name)
        pulumi.set(__self__, "use_source_ip", use_source_ip)

    @property
    @pulumi.getter(name="hashKey")
    def hash_key(self) -> builtins.str:
        """
        一致性哈希方式，取值：UseSourceIp：基于源IP地址。HttpQueryParameterName：基于参数。HttpHeaderName：基于头。HTTPCookie：基于cookie。
        """
        return pulumi.get(self, "hash_key")

    @property
    @pulumi.getter(name="httpCookie")
    def http_cookie(self) -> 'outputs.GetUpstreamLoadBalancerSettingsConsistentHashLbHttpCookieResult':
        """
        Cookie。
        """
        return pulumi.get(self, "http_cookie")

    @property
    @pulumi.getter(name="httpHeaderName")
    def http_header_name(self) -> builtins.str:
        """
        参数。支持ASCII可打印字符，长度限制为1~256个字符。
        """
        return pulumi.get(self, "http_header_name")

    @property
    @pulumi.getter(name="httpQueryParameterName")
    def http_query_parameter_name(self) -> builtins.str:
        """
        参数。支持ASCII可打印字符，长度限制为1~256个字符。
        """
        return pulumi.get(self, "http_query_parameter_name")

    @property
    @pulumi.getter(name="useSourceIp")
    def use_source_ip(self) -> builtins.str:
        """
        源IP地址。
        """
        return pulumi.get(self, "use_source_ip")


@pulumi.output_type
class GetUpstreamLoadBalancerSettingsConsistentHashLbHttpCookieResult(dict):
    def __init__(__self__, *,
                 name: builtins.str,
                 path: builtins.str,
                 ttl: builtins.int):
        """
        :param builtins.str name: 名称。支持ASCII可打印字符，长度限制为0~256个字符。
        :param builtins.str path: 路径。支持ASCII可打印字符，长度限制为1~256个字符。
        :param builtins.int ttl: 有效期。单位为秒。
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "ttl", ttl)

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        名称。支持ASCII可打印字符，长度限制为0~256个字符。
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def path(self) -> builtins.str:
        """
        路径。支持ASCII可打印字符，长度限制为1~256个字符。
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def ttl(self) -> builtins.int:
        """
        有效期。单位为秒。
        """
        return pulumi.get(self, "ttl")


@pulumi.output_type
class GetUpstreamSourceIngressSettingsResult(dict):
    def __init__(__self__, *,
                 enable_all_ingress_classes: builtins.bool,
                 enable_all_namespaces: builtins.bool,
                 enable_ingress: builtins.bool,
                 enable_ingress_without_ingress_class: builtins.bool,
                 ingress_classes: Sequence[builtins.str],
                 update_status: builtins.bool,
                 watch_namespaces: Sequence[builtins.str]):
        """
        :param builtins.bool enable_all_ingress_classes: 是否启用所有Ingress类。
        :param builtins.bool enable_all_namespaces: 是否全部命名空间。
        :param builtins.bool enable_ingress: 是否开启。
        :param builtins.bool enable_ingress_without_ingress_class: 是否监听IngressClass为空的资源。
        :param Sequence[builtins.str] ingress_classes: 指定IngressClass。
        :param builtins.bool update_status: 流量入口切换。开启后，当前集群Ingress中Status的IP地址会被修改为当前网关的IP地址。
        :param Sequence[builtins.str] watch_namespaces: 指定命名空间。
        """
        pulumi.set(__self__, "enable_all_ingress_classes", enable_all_ingress_classes)
        pulumi.set(__self__, "enable_all_namespaces", enable_all_namespaces)
        pulumi.set(__self__, "enable_ingress", enable_ingress)
        pulumi.set(__self__, "enable_ingress_without_ingress_class", enable_ingress_without_ingress_class)
        pulumi.set(__self__, "ingress_classes", ingress_classes)
        pulumi.set(__self__, "update_status", update_status)
        pulumi.set(__self__, "watch_namespaces", watch_namespaces)

    @property
    @pulumi.getter(name="enableAllIngressClasses")
    def enable_all_ingress_classes(self) -> builtins.bool:
        """
        是否启用所有Ingress类。
        """
        return pulumi.get(self, "enable_all_ingress_classes")

    @property
    @pulumi.getter(name="enableAllNamespaces")
    def enable_all_namespaces(self) -> builtins.bool:
        """
        是否全部命名空间。
        """
        return pulumi.get(self, "enable_all_namespaces")

    @property
    @pulumi.getter(name="enableIngress")
    def enable_ingress(self) -> builtins.bool:
        """
        是否开启。
        """
        return pulumi.get(self, "enable_ingress")

    @property
    @pulumi.getter(name="enableIngressWithoutIngressClass")
    def enable_ingress_without_ingress_class(self) -> builtins.bool:
        """
        是否监听IngressClass为空的资源。
        """
        return pulumi.get(self, "enable_ingress_without_ingress_class")

    @property
    @pulumi.getter(name="ingressClasses")
    def ingress_classes(self) -> Sequence[builtins.str]:
        """
        指定IngressClass。
        """
        return pulumi.get(self, "ingress_classes")

    @property
    @pulumi.getter(name="updateStatus")
    def update_status(self) -> builtins.bool:
        """
        流量入口切换。开启后，当前集群Ingress中Status的IP地址会被修改为当前网关的IP地址。
        """
        return pulumi.get(self, "update_status")

    @property
    @pulumi.getter(name="watchNamespaces")
    def watch_namespaces(self) -> Sequence[builtins.str]:
        """
        指定命名空间。
        """
        return pulumi.get(self, "watch_namespaces")


@pulumi.output_type
class GetUpstreamSourceSourceSpecResult(dict):
    def __init__(__self__, *,
                 k8_s_source: 'outputs.GetUpstreamSourceSourceSpecK8SSourceResult',
                 nacos_source: 'outputs.GetUpstreamSourceSourceSpecNacosSourceResult'):
        """
        :param 'GetUpstreamSourceSourceSpecK8SSourceArgs' k8_s_source: 容器集群来源。
        :param 'GetUpstreamSourceSourceSpecNacosSourceArgs' nacos_source: 注册中心来源。
        """
        pulumi.set(__self__, "k8_s_source", k8_s_source)
        pulumi.set(__self__, "nacos_source", nacos_source)

    @property
    @pulumi.getter(name="k8SSource")
    def k8_s_source(self) -> 'outputs.GetUpstreamSourceSourceSpecK8SSourceResult':
        """
        容器集群来源。
        """
        return pulumi.get(self, "k8_s_source")

    @property
    @pulumi.getter(name="nacosSource")
    def nacos_source(self) -> 'outputs.GetUpstreamSourceSourceSpecNacosSourceResult':
        """
        注册中心来源。
        """
        return pulumi.get(self, "nacos_source")


@pulumi.output_type
class GetUpstreamSourceSourceSpecK8SSourceResult(dict):
    def __init__(__self__, *,
                 cluster_id: builtins.str,
                 cluster_type: builtins.str):
        """
        :param builtins.str cluster_id: 集群ID。
        :param builtins.str cluster_type: 集群类型。
        """
        pulumi.set(__self__, "cluster_id", cluster_id)
        pulumi.set(__self__, "cluster_type", cluster_type)

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> builtins.str:
        """
        集群ID。
        """
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter(name="clusterType")
    def cluster_type(self) -> builtins.str:
        """
        集群类型。
        """
        return pulumi.get(self, "cluster_type")


@pulumi.output_type
class GetUpstreamSourceSourceSpecNacosSourceResult(dict):
    def __init__(__self__, *,
                 auth_config: 'outputs.GetUpstreamSourceSourceSpecNacosSourceAuthConfigResult',
                 nacos_id: builtins.str,
                 nacos_name: builtins.str):
        """
        :param 'GetUpstreamSourceSourceSpecNacosSourceAuthConfigArgs' auth_config: 认证配置。
        :param builtins.str nacos_id: Nacos ID。
        :param builtins.str nacos_name: Nacos名称。
        """
        pulumi.set(__self__, "auth_config", auth_config)
        pulumi.set(__self__, "nacos_id", nacos_id)
        pulumi.set(__self__, "nacos_name", nacos_name)

    @property
    @pulumi.getter(name="authConfig")
    def auth_config(self) -> 'outputs.GetUpstreamSourceSourceSpecNacosSourceAuthConfigResult':
        """
        认证配置。
        """
        return pulumi.get(self, "auth_config")

    @property
    @pulumi.getter(name="nacosId")
    def nacos_id(self) -> builtins.str:
        """
        Nacos ID。
        """
        return pulumi.get(self, "nacos_id")

    @property
    @pulumi.getter(name="nacosName")
    def nacos_name(self) -> builtins.str:
        """
        Nacos名称。
        """
        return pulumi.get(self, "nacos_name")


@pulumi.output_type
class GetUpstreamSourceSourceSpecNacosSourceAuthConfigResult(dict):
    def __init__(__self__, *,
                 basic: 'outputs.GetUpstreamSourceSourceSpecNacosSourceAuthConfigBasicResult'):
        """
        :param 'GetUpstreamSourceSourceSpecNacosSourceAuthConfigBasicArgs' basic: Basic认证。
        """
        pulumi.set(__self__, "basic", basic)

    @property
    @pulumi.getter
    def basic(self) -> 'outputs.GetUpstreamSourceSourceSpecNacosSourceAuthConfigBasicResult':
        """
        Basic认证。
        """
        return pulumi.get(self, "basic")


@pulumi.output_type
class GetUpstreamSourceSourceSpecNacosSourceAuthConfigBasicResult(dict):
    def __init__(__self__, *,
                 password: builtins.str,
                 username: builtins.str):
        """
        :param builtins.str password: 密码。
        :param builtins.str username: 用户名。
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def password(self) -> builtins.str:
        """
        密码。
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> builtins.str:
        """
        用户名。
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class GetUpstreamTlsSettingsResult(dict):
    def __init__(__self__, *,
                 sni: builtins.str,
                 tls_mode: builtins.str):
        """
        :param builtins.str sni: SNI。留空时会将访问网关的域名透传到upstream。
        :param builtins.str tls_mode: TLS模式，取值：DISABLE：关闭TLS。SIMPLE：单向TLS。
        """
        pulumi.set(__self__, "sni", sni)
        pulumi.set(__self__, "tls_mode", tls_mode)

    @property
    @pulumi.getter
    def sni(self) -> builtins.str:
        """
        SNI。留空时会将访问网关的域名透传到upstream。
        """
        return pulumi.get(self, "sni")

    @property
    @pulumi.getter(name="tlsMode")
    def tls_mode(self) -> builtins.str:
        """
        TLS模式，取值：DISABLE：关闭TLS。SIMPLE：单向TLS。
        """
        return pulumi.get(self, "tls_mode")


@pulumi.output_type
class GetUpstreamUpstreamSpecResult(dict):
    def __init__(__self__, *,
                 ai_provider: 'outputs.GetUpstreamUpstreamSpecAiProviderResult',
                 ecs_instances: Sequence['outputs.GetUpstreamUpstreamSpecEcsInstanceResult'],
                 k8_s_service: 'outputs.GetUpstreamUpstreamSpecK8SServiceResult',
                 nacos_service: 'outputs.GetUpstreamUpstreamSpecNacosServiceResult',
                 ve_faas: 'outputs.GetUpstreamUpstreamSpecVeFaasResult'):
        """
        :param 'GetUpstreamUpstreamSpecAiProviderArgs' ai_provider: AI模型代理。
        :param Sequence['GetUpstreamUpstreamSpecEcsInstanceArgs'] ecs_instances: 云服务器。
        :param 'GetUpstreamUpstreamSpecK8SServiceArgs' k8_s_service: 容器服务。
        :param 'GetUpstreamUpstreamSpecNacosServiceArgs' nacos_service: 注册中心。
        :param 'GetUpstreamUpstreamSpecVeFaasArgs' ve_faas: 函数服务。
        """
        pulumi.set(__self__, "ai_provider", ai_provider)
        pulumi.set(__self__, "ecs_instances", ecs_instances)
        pulumi.set(__self__, "k8_s_service", k8_s_service)
        pulumi.set(__self__, "nacos_service", nacos_service)
        pulumi.set(__self__, "ve_faas", ve_faas)

    @property
    @pulumi.getter(name="aiProvider")
    def ai_provider(self) -> 'outputs.GetUpstreamUpstreamSpecAiProviderResult':
        """
        AI模型代理。
        """
        return pulumi.get(self, "ai_provider")

    @property
    @pulumi.getter(name="ecsInstances")
    def ecs_instances(self) -> Sequence['outputs.GetUpstreamUpstreamSpecEcsInstanceResult']:
        """
        云服务器。
        """
        return pulumi.get(self, "ecs_instances")

    @property
    @pulumi.getter(name="k8SService")
    def k8_s_service(self) -> 'outputs.GetUpstreamUpstreamSpecK8SServiceResult':
        """
        容器服务。
        """
        return pulumi.get(self, "k8_s_service")

    @property
    @pulumi.getter(name="nacosService")
    def nacos_service(self) -> 'outputs.GetUpstreamUpstreamSpecNacosServiceResult':
        """
        注册中心。
        """
        return pulumi.get(self, "nacos_service")

    @property
    @pulumi.getter(name="veFaas")
    def ve_faas(self) -> 'outputs.GetUpstreamUpstreamSpecVeFaasResult':
        """
        函数服务。
        """
        return pulumi.get(self, "ve_faas")


@pulumi.output_type
class GetUpstreamUpstreamSpecAiProviderResult(dict):
    def __init__(__self__, *,
                 base_url: builtins.str,
                 custom_model_service: 'outputs.GetUpstreamUpstreamSpecAiProviderCustomModelServiceResult',
                 name: builtins.str,
                 token: builtins.str):
        """
        :param builtins.str base_url: 模型地址。
        :param 'GetUpstreamUpstreamSpecAiProviderCustomModelServiceArgs' custom_model_service: 火山自部署模型服务。
        :param builtins.str name: 模型服务商名称。
        :param builtins.str token: 模型API key。
        """
        pulumi.set(__self__, "base_url", base_url)
        pulumi.set(__self__, "custom_model_service", custom_model_service)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "token", token)

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> builtins.str:
        """
        模型地址。
        """
        return pulumi.get(self, "base_url")

    @property
    @pulumi.getter(name="customModelService")
    def custom_model_service(self) -> 'outputs.GetUpstreamUpstreamSpecAiProviderCustomModelServiceResult':
        """
        火山自部署模型服务。
        """
        return pulumi.get(self, "custom_model_service")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        模型服务商名称。
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def token(self) -> builtins.str:
        """
        模型API key。
        """
        return pulumi.get(self, "token")


@pulumi.output_type
class GetUpstreamUpstreamSpecAiProviderCustomModelServiceResult(dict):
    def __init__(__self__, *,
                 name: builtins.str,
                 namespace: builtins.str,
                 port: builtins.int):
        """
        :param builtins.str name: 模型服务名称。
        :param builtins.str namespace: 命名空间。
        :param builtins.int port: 端口。
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        模型服务名称。
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def namespace(self) -> builtins.str:
        """
        命名空间。
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter
    def port(self) -> builtins.int:
        """
        端口。
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class GetUpstreamUpstreamSpecEcsInstanceResult(dict):
    def __init__(__self__, *,
                 ecs_id: builtins.str,
                 ip: builtins.str,
                 port: builtins.int):
        """
        :param builtins.str ecs_id: 云服务器ID。
        :param builtins.str ip: IP地址。
        :param builtins.int port: 端口。
        """
        pulumi.set(__self__, "ecs_id", ecs_id)
        pulumi.set(__self__, "ip", ip)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter(name="ecsId")
    def ecs_id(self) -> builtins.str:
        """
        云服务器ID。
        """
        return pulumi.get(self, "ecs_id")

    @property
    @pulumi.getter
    def ip(self) -> builtins.str:
        """
        IP地址。
        """
        return pulumi.get(self, "ip")

    @property
    @pulumi.getter
    def port(self) -> builtins.int:
        """
        端口。
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class GetUpstreamUpstreamSpecK8SServiceResult(dict):
    def __init__(__self__, *,
                 name: builtins.str,
                 namespace: builtins.str,
                 port: builtins.int):
        """
        :param builtins.str name: 容器服务名称。长度限制为2~63个字符。
        :param builtins.str namespace: 命名空间。长度限制为2~63个字符。
        :param builtins.int port: 端口。
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        容器服务名称。长度限制为2~63个字符。
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def namespace(self) -> builtins.str:
        """
        命名空间。长度限制为2~63个字符。
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter
    def port(self) -> builtins.int:
        """
        端口。
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class GetUpstreamUpstreamSpecNacosServiceResult(dict):
    def __init__(__self__, *,
                 group: builtins.str,
                 namespace: builtins.str,
                 namespace_id: builtins.str,
                 service: builtins.str,
                 upstream_source_id: builtins.str):
        """
        :param builtins.str group: 分组。
        :param builtins.str namespace: 命名空间。
        :param builtins.str namespace_id: 命名空间ID。
        :param builtins.str service: 服务。
        :param builtins.str upstream_source_id: Upstream来源ID。
        """
        pulumi.set(__self__, "group", group)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "namespace_id", namespace_id)
        pulumi.set(__self__, "service", service)
        pulumi.set(__self__, "upstream_source_id", upstream_source_id)

    @property
    @pulumi.getter
    def group(self) -> builtins.str:
        """
        分组。
        """
        return pulumi.get(self, "group")

    @property
    @pulumi.getter
    def namespace(self) -> builtins.str:
        """
        命名空间。
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter(name="namespaceId")
    def namespace_id(self) -> builtins.str:
        """
        命名空间ID。
        """
        return pulumi.get(self, "namespace_id")

    @property
    @pulumi.getter
    def service(self) -> builtins.str:
        """
        服务。
        """
        return pulumi.get(self, "service")

    @property
    @pulumi.getter(name="upstreamSourceId")
    def upstream_source_id(self) -> builtins.str:
        """
        Upstream来源ID。
        """
        return pulumi.get(self, "upstream_source_id")


@pulumi.output_type
class GetUpstreamUpstreamSpecVeFaasResult(dict):
    def __init__(__self__, *,
                 function_id: builtins.str):
        """
        :param builtins.str function_id: 函数ID。
        """
        pulumi.set(__self__, "function_id", function_id)

    @property
    @pulumi.getter(name="functionId")
    def function_id(self) -> builtins.str:
        """
        函数ID。
        """
        return pulumi.get(self, "function_id")


@pulumi.output_type
class GetUpstreamVersionDetailResult(dict):
    def __init__(__self__, *,
                 labels: Sequence['outputs.GetUpstreamVersionDetailLabelResult'],
                 name: builtins.str,
                 update_time: builtins.str):
        """
        :param Sequence['GetUpstreamVersionDetailLabelArgs'] labels: 标签。
        :param builtins.str name: 版本名称。支持大小写字母、数字和中划线（-），长度限制为2~63个字符。不能以中划线（-）开头。
        :param builtins.str update_time: 更新时间。
        """
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "update_time", update_time)

    @property
    @pulumi.getter
    def labels(self) -> Sequence['outputs.GetUpstreamVersionDetailLabelResult']:
        """
        标签。
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        版本名称。支持大小写字母、数字和中划线（-），长度限制为2~63个字符。不能以中划线（-）开头。
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="updateTime")
    def update_time(self) -> builtins.str:
        """
        更新时间。
        """
        return pulumi.get(self, "update_time")


@pulumi.output_type
class GetUpstreamVersionDetailLabelResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 value: builtins.str):
        """
        :param builtins.str key: 键。
        :param builtins.str value: 值。
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        键。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        """
        值。
        """
        return pulumi.get(self, "value")


